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

Question

pretty simple question:

Given an array, find all subsets which sum to value k

I am trying to do this in Java and seem to have found a solution which solves it in O(n^2) time. Is this solution a correct O(n^2) implementation?

      @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();
            }
        }
    }

I have tried it with various examples and have not found any that seem to break it. However, when I have searched online, this does not appear to be the common solution to the problem, and many solution claim this problem is O(2^n).

PS This is not a homework question, I'm a brogrammer with a job trying to work on my Comp Sci fundamentals in Java. Thanks!

Answer 1

No this is not correct.Take this simple example

Your array is 4,6,1,2,3,1 and target sum is 7 then in your logic it would only find (4,3) (6,1) (1,2,3,1) your code would miss (4,2,1), (4,3).

I would refer to go through wiki

Answer 2

An elegant solution is to simply think of a subset as each member answering the question "Am I in or not?" So essentially each can answer yes/no, so you have 2 ^N subsets(including the empty subset). The most natural way to code this up is to recurse through each element and do one of the following:

1. Pick it
2. Skip it

Thus the time complexity is O(2 ^N ) simply because you have so many answers possible in the worst case.