从一组砖块中创建 2 个等高的柱子

Question

问题陈述：

有 N 块积木 (a1, a2, ...., aN)。每块砖的长度为 L1, L2, ...., LN)。使用提供的砖块制作 2 个最高的平行柱子（相同长度的柱子）。

约束：

1. 有 N 块砖。 5
2. 每块砖的长度。 1
3. 砖块长度的总和

砖块的长度没有按尺寸顺序给出。可能有多个具有相同长度的砖块。并非所有的砖都必须用来制作柱子。

例子：

第一个例子-

N = 5
2、3、4、1、6

可能的组合：
(2, 6) 和 (3, 4, 1)

答案：8

我的方法：

找到 2 个平行柱子的最大可能长度，即。地板（N / 2）。然后，使用 DP 找到所有可能使用所有积木的总和长度。从可能的最高总和

上述方法的问题在于它只检查元素的一个子集以形成所需的总和。应该检查可以形成所需总和的所有可能子集，然后对于这些子集中的每一个，使用剩余的元素检查是否可以形成相同的所需总和。问题是在我目前的方法中实现这一点。

第二个例子-

N = 6
3、2、6、4、7、1

可能的组合：
(3, 2, 6) 和 (7, 4)

答案：11

我的代码中的问题可能出现在这种情况下，具体取决于元素（砖块长度）作为输入的顺序。第一个集合可能是使用元素 (3, 7, 1) = 11 形成的，但第二个集合 (2, 6, 4) 不能形成 sum = 11。因此，我的代码开始寻找下一个可能的最大值总和。 10 错了。

有人可以建议我目前的方法更好的方法或可能的改进吗？

Answer 1

我认为您可以通过动态编程来解决这个问题，其中对于每一对 (x, y)，您可以计算出是否可以使用与目前考虑的砖块不同的砖块来构建长度为 x 和 y 的柱子。

依次考虑每块砖。一开始只有 (0, 0) 是可能的。当你看到一块长度为 L 的砖块时，对于每个可能的柱子 (x, y) 都有三个后代 - (x, y)（忽略砖块），（x + L, y）（使用第一根柱子上的砖块） , 和 (x, y + L)（使用第二根柱子上的砖块）。

因此，在您考虑了所有积木之后，您将获得一长串可能的配对，您只需选择具有相同长度且尽可能长的两根柱子的配对即可。只要不存在太多不同的对（您可以从列表中删除任何重复项），这将是实用的。

假设砖块的长度是整数并且最大柱子长度是 1000，那么只有 1001 * 1001 个可能的对，所以这应该是实用的，事实上，如果你通过一个大小为 [ 的数组来存储对，这可能是最简单的。 1001, 1001] 并将条目 [x, y] 设置为 1 如果对 (x, y) 是可能的，否则设置为 0。

对于示例的前几个步骤，可达状态是

(0,0) 什么都不考虑

(0,3) (3,0) (0,0) 考虑 3

(0,5) (2,3) (0,3) (5,0) (3,0) (0,2) (2,0) (0,0) 考虑到 3 和 2

可达状态的数量起初增长得非常快，但由于我们只考虑 0..1000 的值，而且我们只关心数组是否可达，我们可以使用维度为 1001x1001 的布尔数组来维护它们

Answer 2

嗯，这个问题可以简单地使用递归来解决。但是对于较大的 n 值，它不会是有效的。这是我的代码

#include <iostream>
using namespace std;

void solve(int a[], int vis[], int p1, int p2, int n, int &ans){
    if(p1 == p2){

        if(p1 > ans){
            ans = p1;
        }
    }

    for(int i=0 ; i<n ; ++i){

        if(vis[i] == 0){
            vis[i] = 1;
            solve(a, vis, p1 + a[i], p2, n, ans);
            solve(a, vis, p1, p2 + a[i], n, ans);
            vis[i] = 0;
        }
    }
}
int main(){

    int n;
    cin>>n;
    int a[n];

    for(int i=0 ; i<n ; ++i){
        cin>>a[i];
    }

    int vis[n] = {0};
    int ans = -1;
    solve(a,vis,0,0,n,ans);

    cout<<ans;
    return 0;
}

Answer 3

最近我在准备三星能力测试时尝试解决这个问题。我构建了解决方案，这可能会帮助你们练习。感谢https://stackoverflow.com/users/240457/mcdowella，我能够使用他的策略解决这个问题。

public class Pillars {
    public static int h=0,mh=0; 
    public static void main(String[] args)  {   
        java.util.Scanner scan = new java.util.Scanner (System.in);
        int n = scan.nextInt();
        int a[]=new int[n];     
        for(int i=0;i<n;i++)
        {
            a[i]=scan.nextInt();
            mh+=a[i];
        }
        mh/=2;// the height of the two pillars is the total, then single pillar can't be more than half of total 
        maxHeight(0,0,a,0);
        // if no pillars can be built using the data, this print statement is executed
        System.out.println("Maximum Height Formed with the given Data "+h);     
    }

    public static void maxHeight(int x,int y,int a[],int i)
    {
        if(x==y && x!=0 && x>h)// whether the heights formed are equal or not 
        {
            h=x;
            if(h==mh) // if equal then print and exit the program
            {
                System.out.println("Maximum Height Formed with the given Data "+h);
                System.exit(0);
            }
        }
        if(i<a.length )
        {
            maxHeight(x+a[i],y,a,i+1);
            maxHeight(x,y+a[i],a,i+1);          
        }       
    }
}