题目介绍

力扣39题：leetcode-cn.com/problems/co…

回溯

思路在图里

• ×：当前组合和之前生成的组合重复了。
• △：当前求和 > target，不能选下去了，返回。
• ○：求和正好 == target，加入解集，并返回。

利用后两个约束条件做剪枝，较为简单，设置递归出口如下：

if (sum >= target) {
  if (sum == target) {
    res.push(temp.slice()); // 加入解集
  }
  return;     // 结束当前递归
}

不产生重复组合怎么限制（剪枝）？ 如图，只要限制下一次选择的起点，是基于本次的选择，这样下一次就不会选到本次选择同层左边的数。即通过控制 for 遍历的起点，去掉会产生重复组合的选项。

for (let i = start; i < candidates.length; i++) { // 枚举当前可选的数，从start开始
    temp.push(candidates[i]);          // 选这个数
    dfs(i, temp, sum + candidates[i]); // 基于此，继续选择，传i，下次就不会选到i左边的数
    temp.pop();   // 撤销选择，回到选择candidates[i]之前的状态，继续尝试选同层右边的数
}

注意，子递归传了 i 而不是 i+1 ，因为元素可以重复选入集合，如果传 i+1 就不重复了。

代码如下：

public class Solution {

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        int len = candidates.length;
        List<List<Integer>> res = new ArrayList<>();
        if (len == 0) {
            return res;
        }
        Deque<Integer> path = new ArrayDeque<>();
        dfs(candidates, 0, len, target, path, res);
        return res;
    }

    /**
     * @param candidates 候选数组
     * @param begin      搜索起点
     * @param len        冗余变量，是 candidates 里的属性，可以不传
     * @param target     每减去一个元素，目标值变小
     * @param path       从根结点到叶子结点的路径，是一个栈
     * @param res        结果集列表
     */
    private void dfs(int[] candidates, int begin, int len, int target, Deque<Integer> path, List<List<Integer>> res) {
        // target 为负数和 0 的时候不再产生新的孩子结点
        if (target < 0) {
            return;
        }
        if (target == 0) {
            res.add(new ArrayList<>(path));
            return;
        }

        // 重点理解这里从 begin 开始搜索的语意
        for (int i = begin; i < len; i++) {
            path.addLast(candidates[i]);
            // 基于此继续选择，传i，下一次就不会选到i左边的数
            dfs(candidates, i, len, target - candidates[i], path, res);
            // 状态重置
            path.removeLast();
        }
    }
}