LeetCode39.40 组合总和和组合总和2

组合总和

题目要求

给你一个 无重复元素 的整数数组 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
输出: []

破题思路

类似于全排列，但是假如不做剪枝去重的话，会有一些重复的集合出现在答案集合中。

我们考虑在搜索过程中通过剪枝进行去重。观察下图，重复子集是在以不同顺序选择数组元素时产生的，具体来看：

第一轮和第二轮分别选择 3 , 4 ，会生成包含这两个元素的所有子集，记为 [3,4,⋯] 。
若第一轮选择 4 ，则第二轮应该跳过 3 ，因为该选择产生的子集 [4,3,⋯] 和 1. 中生成的子集完全重复。
分支越靠右，需要排除的分支也越多，例如：

前两轮选择 3 , 5 ，生成子集 [3,5,⋯] 。
前两轮选择 4 , 5 ，生成子集 [4,5,⋯] 。
若第一轮选择 5 ，则第二轮应该跳过 3 和 4 ，因为子集 [5,3,⋯] 和子集 [5,4,⋯] 和 1. , 2. 中生成的子集完全重复。

为实现该剪枝，我们初始化变量 start ，用于指示遍历起点。当做出选择 xi​ 后，设定下一轮从索引 i 开始遍历。

除此之外，我们还对代码进行了两项优化：

• 在开启搜索前，先将数组 nums 排序。在遍历所有选择时，当子集和超过 target 时直接结束循环，因为后边的元素更大，其子集和都一定会超过 target 。
• 省去元素和变量 total，通过在 target 上执行减法来统计元素和，当 target 等于 0 时记录解。

题解代码

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<Integer> state = new ArrayList<>(); // 状态（子集）
        Arrays.sort(candidates); // 对 candidates 进行排序
        int start = 0; // 遍历起始点
        List<List<Integer>> res = new ArrayList<>(); // 结果列表（子集列表）
        dfs(target, candidates, start, state, res);
        return res;
    }


    //递推工作
    //每一层就是每一轮选择，而每一轮选择中又可以选择choice数组中从start开始的所有元素
    //从start开始就是避免元素重复添加，也就是剪枝
    public void dfs(int target, int[] choices, int start, List<Integer> state, List<List<Integer>> res){
        //target每次都减去choices[i],假如等于0的话，则当前state里面的元素是符合的。
        if(target == 0){
            res.add(new ArrayList<>(state));
            return;
        }
        //剪枝：从start开始，避免生成重复子集
        for(int i = start; i < choices.length ;i++){
            //假如当前元素加进去之后大于target，后面的元素必定大于target，则结束该轮选择
            if(target - choices[i] < 0){
                break;
            }
            //把当前元素加进状态子集中
            state.add(choices[i]);
            //减去当前元素,进行下一轮选择
            dfs(target - choices[i], choices, i, state, res);
            //下一轮结束，把当前轮的当次元素（choice【i】）弹出，开始下一次循环
            state.remove(state.size() - 1);
        }
    }
}

 

 组合总和2

题目要求

给定一个候选人编号的集合 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的每个数字在每个组合中只能使用 一次 。

注意：解集不能包含重复的组合。 

示例 1:

输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]

示例 2:

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

破题思路

相比于上题，本题的输入数组可能包含重复元素，这引入了新的问题。例如，给定数组 4,4,5和目标元素 9 ，则现有代码的输出结果为 [4,5],[4,5] ，出现了重复子集。

造成这种重复的原因是相等元素在某轮中被多次选择。如下图所示，第一轮共有三个选择，其中两个都为 4 ，会产生两个重复的搜索分支，从而输出重复子集；同理，第二轮的两个 4 也会产生重复子集。

相等元素剪枝：
为解决此问题，我们需要限制相等元素在每一轮中只被选择一次。实现方式比较巧妙：由于数组是已排序的，因此相等元素都是相邻的。这意味着在某轮选择中，若当前元素与其左边元素相等，则说明它已经被选择过，因此直接跳过当前元素。

与此同时，本题规定中的每个数组元素只能被选择一次。幸运的是，我们也可以利用变量 start 来满足该约束：当做出选择 xi后，设定下一轮从索引 i+1 开始向后遍历。这样即能去除重复子集，也能避免重复选择元素。

题解代码

class Solution {
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<Integer> state = new ArrayList<>();
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(candidates);
        int start = 0;
        backtrack(state, target, candidates, start, res);
        //回溯
        return res;
    }

    public void backtrack(List<Integer> state, int target, int[] choice, int start, List<List<Integer>> res){
        //如果在当前轮数中，target==0，说明state中的所有元素符合题目要求，故返回
        //返回上一轮，开始下一次循环
        if(target == 0){
           res.add(new ArrayList<>(state));
           return; 
        }
        //在一轮中，会执行start到choice最后一个元素那么多次的循环
        //每一轮就是固定一个元素，一轮当中的每一次是具体元素的值
        for(int i = start; i < choice.length; i++){
            //假如该轮的该次元素加进去之后大于target，则后面元素取消循环。
            if(target - choice[i] < 0){
                break;
            }
            //假如当前下边大于开始下标，且当前元素的值等于左边元素，则跳过当前元素，进行下一次循环
            if(i > start && choice[i]==choice[i-1]){
                continue;
            }
            //当前元素加入状态子集
            state.add(choice[i]);
            //开始下一轮，由于有去除重复元素的原因，所以在choice数组中，要跳过当前的元素，从下一个元素开始下一轮
            backtrack(state, target - choice[i], choice, i+1, res);
            //回溯结束，去掉该次循环中加入状态子集的元素
            state.remove(state.size() - 1);
        }
    }


}

下图展示了数组 [4,4,5] 和目标元素 9 的回溯过程，共包含四种剪枝操作。请你将图示与代码注释相结合，理解整个搜索过程，以及每种剪枝操作是如何工作的。