Question

我有一个数组列表，其中排序的数字越来越多。我有一个目标值，我必须找到我的数组中目标值的所有可能组合。所以如果我有array = [1,1,3,5,6,7]并且我的目标值是8那么程序应该计算：

1+1+6 =8
1+7 = 8
1+7 = 8
3 + 5 = 8,

它应该返回4.

这是我的实现：

public static int numberOfConnections(int[] e, int b){
        int result = 0;
        int temp = 0;
        for(int i = 0; i < e.length; i++){
            for(int j = 0; j < e.length; j++){
                temp += e[j];
                if(temp > b){
                    temp = 0;
                }
                else if( temp == b){
                    result++;
                    temp = 0;
                }
                else if(temp < b && i == edges.size()){
                    result++;
                }
            }
        }
        return result;
    }

我做错了什么？我得到了错误的结果。

Answer 1

如果您不想使用递归策略，则可以使用与位图相同大小的 int数组和一个布尔数组。

布尔数组告诉你的程序，int数组中的哪些值应该存在于实际计算中。

以您的问题为例，可以按照以下方式完成：

值= [1,1,3,5,6,7]

位图=选定值= 8

（110010）= 1 + 1 + 6 = 8

（100001）= 1 + 7 = 8

（010001）= 1 + 7 = 8

（001100）= 3 + 5 = 8

这将在示例中生成2^values.length = 64个不同的组合。

<强> !!!编辑!!!

我很感兴趣，如果我的想法会成功，那么这是我的尝试：

public static void main(String[] args) {
    int[] values = { 1, 1, 3, 5, 6, 7 };
    int target = 8;

    for (int i = 0; i < (int) Math.pow(2, values.length); i++) {
        boolean[] bitmap = createBitmap(i, values.length);
        int result = calculateResult(values, bitmap);
        if (result == target) {
            System.out.printf("%s = %d\n", 
                getSumString(values, bitmap),
                result);
        }
    }
}

private static boolean[] createBitmap(int value, int arrayLength) {
    boolean[] bits = new boolean[arrayLength];

    int actual;
    for (int i = bits.length - 1; i >= 0; i--) {
        actual = getValue(bits);
        if (actual == value)
            break;
        else if (actual + (int) Math.pow(2, i) <= value)
            bits[i] = true;
    }

    return bits;
}

private static int getValue(boolean[] bits) {
    int value = 0;
    for (int i = bits.length - 1; i >= 0; i--)
        if (bits[i])
            value += (int) Math.pow(2, i);

    return value;
}

private static int calculateResult(final int[] values, boolean[] used) {
    int sum = 0;
    for (int i = 0; i < used.length; i++)
        if (used[i])
            sum += values[i];
    return sum;
}

private static String getSumString(int[] values, boolean[] used) {
    String sumString = "";
    for (int i = 0; i < used.length; i++)
        if (used[i])
            sumString += values[i] + " ";
    return sumString;
}

执行main()方法会导致

3 5 = 8

1 1 6 = 8

1 7 = 8

1 7 = 8

所以我认为这是一种正确的方法： - ）

Answer 2

一些错误：

1）在内部循环中，你不应该从0开始，而是从i + 1开始。否则，你计算两次相同的节点。

2）你只检查2的组合，而不是更多！你需要一个递归方法。

找到int数组中值的所有可能组合

2 个答案: