Java 给定一个数组，求和为k值的所有子集

非常简单的问题：

给定一个数组，求和为k值的所有子集

我正试图用Java实现这一点，并且似乎已经找到了一个解决方案，可以在O（n^2）时间内解决它。此解决方案是正确的O（n^2）实现吗

      @Test
    public void testFindAllSubsets() {
        int[] array = {4,6,1,6,2,1,7};
        int k=7;
                 // here the algorithm starts
        for(int i = 0; i < array.length;i++){
            // now work backwords
            int sum = array[i];
            List<Integer> subset = new ArrayList<Integer>();
            subset.add(array[i]);
            for(int j = array.length -1; j > i && sum < k; j--){
                int newSum = sum + array[j];
                                    // if the sum is greater, than ditch this subset
                if(newSum <= k){
                    subset.add(array[j]);
                    sum = newSum;
                }
            }
            // we won't always find a subset, but if we do print it out
            if(sum == k){
                System.out.print("{");
                System.out.print(subset.get(0));
                for(int l = 1; l < subset.size(); l++){
                    System.out.print(","+subset.get(l));
                }
                System.out.print("}");
                System.out.println();
            }
        }
    }

@测试
公共无效testFindAllSubsets（）{
int[]数组={4,6,1,6,2,1,7}；
int k=7；
//算法从这里开始
for（int i=0；ii&&sum如果（newSumNo），这是不正确的

你的数组是4,6,1,2,3,1，目标和是7，那么在你的逻辑中
只会发现（4,3）（6,1）（1,2,3,1）您的代码将丢失（4,2,1）、（4,3）

我想说的是“通过”
不，这是不正确的。举个简单的例子

你的数组是4,6,1,2,3,1，目标和是7，那么在你的逻辑中
只会发现（4,3）（6,1）（1,2,3,1）您的代码将丢失（4,2,1）、（4,3）

我想说的是遍历一个优雅的解决方案是简单地将一个子集视为回答“我在不在？”问题的每个成员，因此基本上每个成员都可以回答是/否，因此有2N个子集（包括空的子集）。最自然的编码方式是递归遍历每个元素并执行以下操作之一：

选择它
跳过它
因此，时间复杂度为O（2N），这仅仅是因为在最坏的情况下，您可能有这么多答案。
一个优雅的解决方案是，简单地将一个子集视为回答“我是否在？”问题的每个成员，因此基本上每个成员都可以回答是/否，因此您有2N个子集（包括空子集）。编写此代码最自然的方法是递归每个元素并执行以下操作之一：

选择它
跳过它
因此，时间复杂度是O（2N），因为在最坏的情况下，有很多可能的答案。
最坏的情况总是O（2^n）考虑到数字是0的情况，所有ELM都是0，你必须生成2 ^ n个列表，因为每个子集都是K，如果你能把AVG的情况降到n^ 2，我会很惊讶，只要你不觉得不好，因为如果你是正确的，你会证明“代码> p= NP＜/代码>嗯，最坏的情况总是O（2 ^ n）。考虑到数字是0的情况，所有的ELM都是0，你必须生成2 ^ n个列表，因为每个子集都和K相称，如果你能把AVG的情况降到n^ 2，我会很惊讶，只要你不觉得不好，因为如果你是正确的，你会证明“代码> p= NP＜/代码>是的，在这个例子中，我的ALGO。Rithm只找到{41,1,2}，{6}，1}和{1,1,3.2}。它忽略了{4，3}，因为它只能考虑每一次迭代的一个集合。谢谢。请指出这个例子。是的，在这种情况下，我的算法只发现{41,1,2}，{6}，1}和{1,1,3.2}。它忽略{4}，3}，因为它只能考虑每次迭代一个集合。谢谢。