加数组的数量直到确定值

Question

对于练习，我必须添加数组的值，直到达到某个值为止，并显示所有可能的组合。

示例：值= 4，数组= {1,2,3}

可能的组合为：1 + 1 + 1 + 1、1 + 1 + 2、1 + 2 + 1、1 + 3、2 + 1 + 1、2 + 2、3 + 1

但是，我的代码似乎不起作用：

public static void main(String[] args) {

    double[] array = { 1., 2., 3. };
    double value = 4.;
    for (int i = 0; i < array.length; i++) {
        addNumber(array, value, i);
    }
}

public static void addNumber(double[] array, double value, int index) {

    double startNumber = array[index];
    double checkSum = 0;

    for (int i = 0; i < array.length; i++) {
        checkSum += array[i] + startNumber;
        if (checkSum == value){
        System.out.println(startNumber + " + " + array[i] + " = " + checkSum);
        } else if (checkSum < value){
            moreNumbers(array, value, checkSum);
        }
        checkSum = 0;
    }
}

public static void moreNumbers (double[] array, double value, double current){

    if (current == value){
        System.out.println(current);
    } else if (current < value) {

        for (int i = 0; i < array.length; i++){             
            current += array[i];
            System.out.println("+ " + array[i] + " = " + current);              
        }
        moreNumbers(array, value, current);
    }       
}

输出：

+ 1.0 = 3.0
+ 2.0 = 5.0
+ 3.0 = 8.0
+ 1.0 = 4.0
+ 2.0 = 6.0
+ 3.0 = 9.0
1.0 + 3.0 = 4.0
+ 1.0 = 4.0
+ 2.0 = 6.0
+ 3.0 = 9.0
2.0 + 2.0 = 4.0
3.0 + 1.0 = 4.0

我相信我在找到正确的算法时遇到了麻烦，因为我只得到了一些组合，但不是全部。

我有一个问题：我正在寻找一种算法，可以帮助我理解本练习，它是逻辑，而不是最终代码。

编辑：在此练习的进一步发展中，我也必须使用类似0.5或0.2的数字，但是数字始终为正，因此这是我希望为其寻找答案的另一个问题。

Answer 1

这是基于组合技术的解决方案之一。

算法：

1. 计算从长度{input}到1的所有组合（重复）。
2. 仅打印那些满足总和条件的组合。

例如，如果输入为4则length = 4的一些不同组合如下：

1 1 1 1
1 1 1 2
.
.
2 1 2 3
.
.
3 3 3 3

现在，我们只打印1 1 1 1因为它加起来等于输入即4并满足条件。

类似地，对于length = 3一些不同的组合如下：

1 1 1
1 1 2
.
.
1 2 1
.
.
3 3 3

现在，我们只打印1 1 2 1 2 1和2 1 1因为它们都满足求和条件。

这是有关如何计算不同组合的简要说明：

1. 组合函数检查数组的最后一个元素，如果不是MAX，则将其递增，然后分支该函数。
2. 如果最后一个元素是max，那么我们将遍历数组以查找不是MAX的下一个数字。
3. 如果上面的扫描由于数组耗尽而失败，那么我们将流程返回到主函数，但是，如果扫描返回的位置不是max，那么我们将该位置的值增加1并将该位置之后的所有值重置为MIN。 我们再次分支该功能。

（它使用递归计算给定长度的所有组合）

代码段：

class Combinations
{
    /* Constants Array (Sorted) */
    private static final double[] ARR_CNST = {0.1,0.2,0.3};
    /* Size of Constant Array */
    private static final int SIZE = 3;

    public static void main (String[] args)
    {
        /* Input Number */
        double input = 0.4;
        /* Start Permutations {Length --> 1} */
        for(int i = (int) (input/ARR_CNST[0]); i > 0; i--) {
            double[] storage = new double[i];
            /* Fill Array With Least Element */
            Arrays.fill(storage,ARR_CNST[0]);
            /* Check Sum Condition */
            if(check(storage,input)) {
                /* Print */
                print(storage);
            }
            /* Calculate Rest of the Combinations */
            calc(storage, input);
        }
    }

    private static void calc(double[] arr, double input) {
        /* Increment Last Element if not MAX */
        if(arr[arr.length - 1] < ARR_CNST[SIZE - 1]) {
            int k = 0;
            while(k < SIZE && arr[arr.length - 1] != ARR_CNST[k++]);
            arr[arr.length - 1] = ARR_CNST[k];
            if(check(arr,input)) {
                print(arr);
            }
            calc(arr, input);
        }

        /* Increment & Reset */
        int i = arr.length - 1;
        while(i >= 0 && arr[i] >= ARR_CNST[SIZE - 1])
            i--;

        if(i >= 0) {
            int k = 0;
            while(k < SIZE && arr[i] != ARR_CNST[k++]);
            arr[i] = ARR_CNST[k];

            for(int x = i + 1; x < arr.length; x++) {
                arr[x] = ARR_CNST[0];
            }

            if(check(arr,input)) {
                print(arr);
            }
            calc(arr, input);
        }

        /* Return */
        return;
    }

    /* Check Sum Condition */
    private static boolean check(double[] arr, double input) {
        double sum = 0;
        for(int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        if(sum == input) {
            return true;
        }
        return false;
    }

    /* Print Array Values */
    private static void print(double[] arr) {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < arr.length; i++) {
            sb.append(arr[i] + " + ");
        }
        System.out.println(sb.substring(0,sb.length() - 3));
    }
}

输出：

0.1 + 0.1 + 0.1 + 0.1
0.1 + 0.1 + 0.2
0.1 + 0.2 + 0.1
0.2 + 0.1 + 0.1
0.1 + 0.3
0.2 + 0.2
0.3 + 0.1

Answer 2

这似乎很容易通过递归来解决，如下所示：

获取4和{1,2,3}的解决方案（在下面写为solution（4，{1,2,3}）就像为

• “ 1 +” +解决方案（3，{1，2，3}）
• “ 2 +” +解决方案（2，{1，2，3}）
• “ 3 +” +解决方案（1，{1、2、3}）

在每一步中，您都减少了数字（如果可用数字列表中的数字当然没有为零），那么您可以确保递归将完成。

您可以有两个结果：

• 不可能（例如您需要产生1，但可用数字列表中没有1）
• 1个或更多潜在解决方案

还有另一件事要注意： 浮点相等 。 ==不会每次都起作用。

该代码想：

public static void main(String[] args) {
    ArrayList<String> solutions = new ArrayList<String>();
    solve("", 1.0d, new Double[] {0.2d, 0.50d}, solutions);
    System.out.println(solutions);
    // [0.2 + 0.2 + 0.2 + 0.2 + 0.2, 0.5 + 0.5]
    solutions.clear();
    solve("", 4d, new Double[] {1d, 2d, 3d}, solutions);
    System.out.println(solutions);
    // [1.0 + 1.0 + 1.0 + 1.0, 1.0 + 1.0 + 2.0, 1.0 + 2.0 + 1.0, 1.0 + 3.0, 2.0 + 1.0 + 1.0, 2.0 + 2.0, 3.0 + 1.0]
}

public static void solve(String subSolution, Double remaining, Double[] authorizedNumbers, List<String> solutions) {
    if (doubleEquals(remaining, 0d)) {
        solutions.add(subSolution);
    } else {
        for(Double authorizedNumber : authorizedNumbers) {
            if (doubleEquals(authorizedNumber, remaining)) {
                solutions.add(subSolution + authorizedNumber);
            } else if (authorizedNumber < remaining) {
                solve(subSolution + authorizedNumber + " + ", remaining - authorizedNumber, authorizedNumbers, solutions);
            }
        }
    }
}

public static boolean doubleEquals(double d1, double d2) {
    return Math.abs(d1 - d2) < 0.000000001d;
}

Answer 3

通用方法是：

1. 选择一个可用数字，然后查看是否等于目标。
2. 如果没有，您可以从可用号码中选择其他任何号码，并将其添加到先前选择的号码中； 再次检查您是否已达到目标。
3. 继续前进，直到达到（或超过）目标金额。

可以这样实现：

public static void startRecursion(int target, int[] numbers) {
  int min = numbers[0];
  for (int i = 1; i < numbers.length; ++i) {
    min = Math.min(min, numbers[i]);
  }
  // We need to choose at most ceil(target / min) numbers.
  int maxPicks = (target + min - 1) / min;
  recurse(new int[maxPicks], 0, 0, target, numbers);
}

private static void recurse(
    int[] picked, int numPicked, int sumOfPicked,
    int target, int[] numbers) {
  if (sumOfPicked == target) {
    // We reached the target! Print out the numbers we chose to get here.
    for (int i = 0; i < numPicked; ++i) {
      if (i != 0) System.out.print(" + ");
      System.out.print(picked[i]);
    }
    System.out.println(" = " + target);
  } else if (sumOfPicked < target) {
    // We haven't reached the target yet.
    // Go through each of the numbers that you can choose from numbers
    // in turn, increasing the sum by this amount.
    for (int i = 0; i < numbers.length; ++i) {
      picked[numPicked] = numbers[i];
      recurse(
          picked, numPicked + 1, sumOfPicked + numbers[i],
          target, numbers);
    }
  } else {
    // We have overshot the target. Since no numbers are negative,
    // we can't get back to the target again.
  }
}