Java 从正数和负数的集合中找出所有可能的等于0的子集和？

如果有一个数组，其中包含一组正数和负数，则打印所有等于0的子集和

我可以想出一种方法，在这种方法中，我可以制作givcen阵列的所有功率集，并检查它们的总和是否为0。但这与优化的解决方案不同 我

阅读后，在网上看到了一个有点类似的问题，看起来它可以用动态规划解决，如下面的程序，以找出是否存在组合 让sum 11只是一个例子

public boolean subsetSum(int input[], int total) {

        boolean T[][] = new boolean[input.length + 1][total + 1];
        for (int i = 0; i <= input.length; i++) {
            T[i][0] = true;
        }

        for (int i = 1; i <= input.length; i++) {
            for (int j = 1; j <= total; j++) {
                if (j - input[i - 1] >= 0) {
                    T[i][j] = T[i - 1][j] || T[i - 1][j - input[i - 1]];
                } else {
                    T[i][j] = T[i-1][j];
                }
            }
        }
        return T[input.length][total];

    }




public static void main(String args[]) {
    TestDynamic ss = new TestDynamic();
   int arr1[] = {2, 3, 7, 8};
    System.out.print(ss.subsetSum(arr1, 11));

}

public boolean子类（int-input[]，int-total）{
布尔T[][]=新布尔[input.length+1][total+1]；
对于（inti=0；i，这里是一个完整的Javascript实现。您可以使用node.js运行它

function target_sum(a, k, x)
{
    if (k == a.length) return [];
    if (a[k] == x) {
        return [[a[k]]];
    } else {
        var s = target_sum(a, k + 1, x);        // not using a[k]
        var t = target_sum(a, k + 1, x - a[k]); // using a[k]
        for (var i = 0; i < t.length; ++i) {
            t[i].unshift(a[k]); // a[k] is part of the solution
            s.push(t[i]);       // merge t[] into s[]
        }
        return s;
    }
}

var s = target_sum([1,4,5,2,7,8,-3,-5,-6,9,3,-7,-1,5,6], 0, 0);
for (var i = 0; i < s.length; ++i)
    console.log(s[i].join(","));

函数目标_和（a，k，x）
{
如果（k==a.length）返回[]；
如果（a[k]==x）{
返回[[a[k]]；
}否则{
var s=target_sum（a，k+1，x）；//不使用[k]
var t=target_sum（a，k+1，x-a[k]）；//使用[k]
对于（变量i=0；i

请注意，这是一个指数算法。不要在大型阵列上使用它

Erwin Rooijakkers也指出了正确的方向。特别是，他给出了另一个算法。我可能在以下方面错了——我认为该算法以速度换取空间。它避免将数组转移到调用堆栈中，但它必须进行更多的递归才能实现这一点

编辑：关于你提到的算法。它不是指数型的，但如果我是对的，它只适用于正数。它的时间复杂度也与目标和成正比，这可能并不理想，取决于输入。
@ErwinRooijakkers在你提供的链接上的解决方案是不完整的，并且是非常高的级别。我无法完全理解它试试这个：；）。