满足总和的数组（具有整数）的所有子集的Java算法？ [关闭]

Question

我正在研究 java 程序，它为您提供了对给定总和有贡献的数组的所有可能集合数。

例如 we have an Array of numbers {1,2,2,3,4,5} these might be unsorted

总和“5”的可能子集/输出是：{1,2,2} {3,2} {4,1} & {5}

我写的解决方案没有达到目的，请有人在这里帮忙并指出算法中的错误或有其他更好的解决方案。

提前致谢。

代码如下：

public static List<List<Integer>> possibleCombinations(int[] array,
    int requiredSum) {
Arrays.sort(array);
List<List<Integer>> result = new ArrayList<List<Integer>>();
HashSet<String> hello = new HashSet<String>();
for (int i = 0; i < array.length; i++) {
    if (array[i] > requiredSum) {
        break;
    } else if (array[i] == requiredSum) {
        List<Integer> single = new ArrayList<Integer>();
        single.add(requiredSum);
        result.add(single);
        return result;
    }
    for (int j = i + 1; j < array.length; j++) {
        if (array[j] > requiredSum) {
            break;
        } else if (array[j] == requiredSum) {
            List<Integer> single = new ArrayList<Integer>();
            single.add(requiredSum);
            result.add(single);
            return result;
        }
        List<Integer> possibility = new ArrayList<Integer>();
        possibility.add(array[i]);
        int sum = 0;
        sum += array[i];
        for (int k = j; k < array.length; k++) {
            if ((sum + array[k]) < requiredSum) {
                possibility.add(array[k]);
                sum += array[k];
            } else if (sum + array[k] == requiredSum) {
                possibility.add(array[k]);
                result.add(possibility);
                break;
            } else {
                if(possibility.isEmpty() || possibility.size()==1){
                    break;
                }
                sum -= possibility.get(possibility.size() - 1);
                possibility.remove(possibility.size() - 1);
                k--;
                continue;
            }
        }

    }
}

return result;

}

Answer 1

希望对你有帮助。 我没有编译代码，但我很确定它会起作用。

它的复杂度为 O(2^N)，其中 N 是元素的数量。

void printSubsetSum(int []nums,int targetSum) {
    int n = nums.length;

    // generate all possible combination from binary representation
    for(int mask=(1<<n)-1;mask>0;mask--) {
        List<Integer> list = new ArrayList<Integer>();

        // check by bit operation
        for(int i=0;i<n;i++) {
            // if ith bit is on then we add our candidate number
            if((mask & (1<<i))!=0) list.add(nums[i]);
        }

        // sum all element in list
        int sum = 0;
        for(int x:list) sum += x;

        // if the sum equals targetSum then we print our list
        if(sum==targetSum) System.out.println(list);
    }
}

我的解决方案如何工作

假设我们有测试输入 {1,2,2,3,4,5}

有 6 个数字，我们想找到 sum = 5 的每个组合。

我的解决方案是生成从 (2^6 - 1) 到 1 的二进制数。

63 = 111111
62 = 111110
61 = 111101
..
3  = 000011
2  = 000010
1  = 000001

对于二进制数位置中的每一个 1，我从 testinput 中选择一个值并将其相加。

例子：

101101 from {1,2,2,3,4,5} that means 1 + 2 + 3 + 5.
000101 from {1,2,2,3,4,5} that means 3 + 5.

Answer 2

我在下面写了算法，但并非在所有情况下都有效，它只打印子集的后续排列。

public static List<List<Integer>> possibleCombinations(int[] array,
        int requiredSum) {
    Arrays.sort(array);
    List<List<Integer>> result = new ArrayList<List<Integer>>();
    HashSet<String> hello = new HashSet<String>();
    for (int i = 0; i < array.length; i++) {
        if (array[i] > requiredSum) {
            break;
        } else if (array[i] == requiredSum) {
            List<Integer> single = new ArrayList<Integer>();
            single.add(requiredSum);
            result.add(single);
            return result;
        }
        for (int j = i + 1; j < array.length; j++) {
            if (array[j] > requiredSum) {
                break;
            } else if (array[j] == requiredSum) {
                List<Integer> single = new ArrayList<Integer>();
                single.add(requiredSum);
                result.add(single);
                return result;
            }
            List<Integer> possibility = new ArrayList<Integer>();
            possibility.add(array[i]);
            int sum = 0;
            sum += array[i];
            for (int k = j; k < array.length; k++) {
                if ((sum + array[k]) < requiredSum) {
                    possibility.add(array[k]);
                    sum += array[k];
                } else if (sum + array[k] == requiredSum) {
                    possibility.add(array[k]);
                    result.add(possibility);
                    break;
                } else {
                    if(possibility.isEmpty() || possibility.size()==1){
                        break;
                    }
                    sum -= possibility.get(possibility.size() - 1);
                    possibility.remove(possibility.size() - 1);
                    k--;
                    continue;
                }
            }

        }
    }

    return result;
}