Java 一种递归算法，用于在给定整数数组的情况下查找每个可能的和？

因此，给定一个数组，例如[3,5,7,2]我想用递归给出所有可能的和的组合，

例如：3,5,7,2,8（3+5），10（3+7），5（3+5）。。。15（3+5+7）

等等。我不确定如何使用java实现这一点

这方面的递归算法可以如下工作：

列表的所有和等于以下各项的并集：

• 第一个数字加上不带第一个数字的子列表的和
• 不带第一个数字的子列表的和

---

最终，递归调用将遇到空列表的停止条件，该列表只有一个和（零）

这里有一种使用伪代码的方法：

getAllPossibleSums(list)
    if(list.length == 1)
        return list[0];
    otherSums = getAllPossibleSums(list[1:end])
    return union(
        otherSums, list[0] + otherSums);

---

数组中的每个数字都有两个选项

使用号码

不要用这个号码

void foo(int[] array, int start, int sum) {
    if(array.length == start) return;
    int val = sum + array[start];
    //print val;
    foo(array, start + 1, val); //use the number
    foo(array, start + 1, sum); //don't use the number
}

最初的调用是

foo（a，0，0）

您有两个分支，一个是添加当前号码的分支，另一个是不添加当前号码的分支。

有史以来最简单的方法：

public static void main(String[] args) {
    int [] A = {3, 5, 7, 2};
    int summation = recursiveSum(A, 0, A.length-1);
    System.out.println(summation);
  }

  static int recursiveSum(int[] Array, int p, int q) {
    int mid = (p+q)/2; //Base case
    if (p>q) return 0; //Base case
    else if (p==q) return Array[p];
    **else
      return  recursiveSum(Array, p, mid) +  recursiveSum(Array, mid + 1, q);**
  }

private int noOfSet;

添加以下方法：

private void checkSum() {
        List<Integer> input = new ArrayList<>();
        input.add(9);
        input.add(8);
        input.add(10);
        input.add(4);
        input.add(5);
        input.add(7);
        input.add(3);

        int targetSum = 15;
        checkSumRecursive(input, targetSum, new ArrayList<Integer>());

    }

    private void checkSumRecursive(List<Integer> remaining, int targetSum, List<Integer> listToSum) {
        // Sum up partial
        int sum = 0;
        for (int x : listToSum) {
            sum += x;
        }

        //Check if sum matched with potential
        if (sum == targetSum) {
            noOfSet++;
            Log.i("Set Count", noOfSet + "");
            for (int value : listToSum) {
                Log.i("Value", value + "");
            }
        }

        //Check sum passed
        if (sum >= targetSum)
            return;

        //Iterate each input character
        for (int i = 0; i < remaining.size(); i++) {
            // Build list of remaining items to iterate
            List<Integer> newRemaining = new ArrayList<>();
            for (int j = i + 1; j < remaining.size(); j++)
                newRemaining.add(remaining.get(j));

            // Update partial list
            List<Integer> newListToSum = new ArrayList<>(listToSum);
            int currentItem = remaining.get(i);
            newListToSum.add(currentItem);
            checkSumRecursive(newRemaining, targetSum, newListToSum);
        }
    }

专用无效校验和（）{
列表输入=新的ArrayList（）；
输入。添加（9）；
输入。添加（8）；
输入。添加（10）；
输入。添加（4）；
输入。添加（5）；
输入。添加（7）；
输入。添加（3）；
int targetSum=15；
checkSumRecursive（输入、目标和、新ArrayList（））；
}
私有void checkSumRecursive（剩余列表、int targetSum、列表listToSum）{
//总结部分
整数和=0；
for（int x:listToSum）{
总和+=x；
}
//检查总和是否与电势匹配
如果（总和==目标总和）{
noOfSet++；
Log.i（“设置计数”，noOfSet+”）；
for（int值：listToSum）{
Log.i（“值”，值+”）；
}
}
//校验和通过
如果（总和>=目标总和）
返回；
//迭代每个输入字符
对于（int i=0；i

---

希望这能对你有所帮助。

@Confluence:他想要递归。你怎么会在这段代码中得到这个词？？严重

动态规划

？？这里哪里是动态的？是的，但至少我在这里描述的内容多次命中相同的递归调用。这就是动态规划。非常类似于递归，如果你喜欢的话，可以简单地用递归实现。嗯，似乎有一种比我简单得多的方法，所以我把我的方法改为纯递归（没有动态编程）。问题是要输出所有可能的和，而不仅仅是总数。

private void checkSum() {
        List<Integer> input = new ArrayList<>();
        input.add(9);
        input.add(8);
        input.add(10);
        input.add(4);
        input.add(5);
        input.add(7);
        input.add(3);

        int targetSum = 15;
        checkSumRecursive(input, targetSum, new ArrayList<Integer>());

    }

    private void checkSumRecursive(List<Integer> remaining, int targetSum, List<Integer> listToSum) {
        // Sum up partial
        int sum = 0;
        for (int x : listToSum) {
            sum += x;
        }

        //Check if sum matched with potential
        if (sum == targetSum) {
            noOfSet++;
            Log.i("Set Count", noOfSet + "");
            for (int value : listToSum) {
                Log.i("Value", value + "");
            }
        }

        //Check sum passed
        if (sum >= targetSum)
            return;

        //Iterate each input character
        for (int i = 0; i < remaining.size(); i++) {
            // Build list of remaining items to iterate
            List<Integer> newRemaining = new ArrayList<>();
            for (int j = i + 1; j < remaining.size(); j++)
                newRemaining.add(remaining.get(j));

            // Update partial list
            List<Integer> newListToSum = new ArrayList<>(listToSum);
            int currentItem = remaining.get(i);
            newListToSum.add(currentItem);
            checkSumRecursive(newRemaining, targetSum, newListToSum);
        }
    }