【LeetCode】hot100—39. 组合总和_回溯

• 原题链接：39. 组合总和

---

---

题目

• 给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。
  candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。
  对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：

输入: candidates = [2], target = 1
输出: []

提示：

• 1 <= candidates.length <= 30
• 2 <= candidates[i] <= 40
• candidates 的所有元素 互不相同
• 1 <= target <= 40

---

1- 思路

• 利用回溯算法解决组合问题，构思组合问题的回溯树是怎么样的。

• 可以看到回溯构造的过程，同层中元素需要去重，同层元素去重 通过 回溯算法中参数 startIndex实现
• path 上的集合元素去重，通过 回溯过程中 backTracing 的 startIndex字段为 i+1 实现，但本题不需要对同路径上元素去重，因此 传入参数为 i

回溯三部曲

• 1. 回溯参数返回值

public List<List<Integer>> combinationSum(int[] candidates, int target)

• 2. 回溯终止条件 & 收集结果逻辑

if (nowSum > target) {
    return;
}

if (nowSum == target) {
    res.add(new ArrayList(path));
}

• 3. 单层回溯逻辑

for (int i = startIndex; i < candidates.length; i++) {
    nowSum += candidates[i];
    path.add(candidates[i]);
    backTracing(candidates, i, target, nowSum);
    nowSum -= candidates[i];
    path.remove(path.size() - 1);
}

---

2- 题解

⭐组合总和 —— 代码实现思路

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();

    public List<List<Integer>> combinationSum(int[] candidates, int target) {

        backTracing(candidates, 0, target, 0);
        return res;
    }

    public void backTracing(int[] candidates, int startIndex, int target, int nowSum) {

        if (nowSum > target) {
            return;
        }

        if (nowSum == target) {
            res.add(new ArrayList(path));
        }

        for (int i = startIndex; i < candidates.length; i++) {
            nowSum += candidates[i];
            path.add(candidates[i]);
            backTracing(candidates, i, target, nowSum);
            nowSum -= candidates[i];
            path.remove(path.size() - 1);
        }
    }

}

---

3- ACM模式

public class hot57_combinationSum {

    static List<List<Integer>> res = new ArrayList<>();
    static List<Integer> path = new ArrayList<>();
    public static List<List<Integer>> combinationSum(int[] candidates,int target){
        backTracing(candidates,0,target,0);
        return res;
    }

    public static void backTracing(int[] candidates,int startIndex,int target,int nowSum){
        if(nowSum>target){
            return;
        }
        if(nowSum==target){
            res.add(new ArrayList<>(path));
        }

        for(int i = startIndex; i < candidates.length;i++){
            path.add(candidates[i]);
            nowSum+=candidates[i];
            backTracing(candidates,i,target,nowSum);
            nowSum-=candidates[i];
            path.remove(path.size()-1);
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入数组长度");
        int n = sc.nextInt();
        System.out.println("输入数组值");
        System.out.println();
        int[] nums = new int[n];
        for(int i = 0 ; i <n;i++){
            nums[i] = sc.nextInt();
        }
        System.out.println("输入目标值");
        int target = sc.nextInt();
        List<List<Integer>> forRes = combinationSum(nums,target);
        for(List<Integer> i :forRes){
            System.out.print(i+" ");
        }
    }
}