回溯法+剪枝解决组合总和问题

1. 问题描述

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的数字可以无限制重复被选取。
说明：

• 所有数字（包括 target）都是正整数。
• 解集不能包含重复的组合。

例子：

• 输入：[2,3,6,7]，target=7。
• 输出：[[2,2,3],[7]]。

2. 解法

根据问题的描述，我们想到了使用树形结构进行遍历来求解。

首先需要确定遍历的深度，到什么地方要终止搜索，不确定这个的话，这棵树就无限深，那么就陷入死循环了。很显然当当前路径上的点之和超过target时要进行回溯，如果等于目标值，不仅要返回还要将当前路径上的结点加入答案列表中；
然后为了避免重复（比如[2,2,3],[2,3,2],[3,2,2]是只能保留一个的），我们要进行观察，发现这三个序列只有第一个是按单调增加排列的，也就是说如果我们对每次的搜索结果进行一个约束，即如果当前遍历的点为n，那么后面遍历到的结点不能比n小，通过一开始对输入进行一个排序预处理，这样的话，就可以解决这个重复的问题；
然后为了减小搜索规模，还要进行剪枝。对于上图，当遍历到2，2，2，2时发现这时的结果大于target，那么我们还需要遍历2，2，2，3吗，显然不用了，因此在进行遍历时我们还可以加一个条件。

3. 实现

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    public void traceBack(int[] candidates, int target, List<Integer> temp, int sum, int start){
        if(sum > target){
            return;
        } 
        if(sum == target){
            //此处一定要重新new一个list，一定一定，不然你ans里面的list全都是temp的影像，temp一变，他们都得变，那最后就是竹篮打水一场空了
            ans.add(new ArrayList<Integer>(temp));
            return;
        }
        for (int i = start; i < candidates.length; i++){
            if (sum + candidates[i] > target) break;
            temp.add(candidates[i]);
            traceBack(candidates, target, temp, sum+candidates[i], i);
            temp.remove(temp.size() - 1);
        }
    }
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<Integer> temp = new ArrayList<>();
        Arrays.sort(candidates);
        traceBack(candidates, target, temp, 0, 0);
        return ans;
    }
}

这里面有一个坑，要注意，就是上面加了注释的地方，一定要new一个新的List对象出来。

4. 全排列或者组合加剪枝的模板

traceBack(nums[n], ans[]){
	if 终止条件{
		新得到一个答案或者没有；
		return;
	}
	for num 遍历nums{
		if 剪枝条件,continue 或是 break;
		否则，遍历到的数字加入ans,ans.add(num);
		进入递归，traceBack()；
		撤销进入递归前的操作,ans.remove(num)；
	}
}

按照上面的模板，写一个全排列问题的代码：

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

    public void traceBack(int[] nums, List<Integer> temp){
    	// 退回条件
        if(temp.size() == nums.length){
        //是否得到新答案，对新答案的处理
            ans.add(new ArrayList<Integer>(temp));
            return;
        }
        //for遍历
        for (int i = 0; i < nums.length; i++){
        	//剪枝条件，continue 或是 break要搞清
            if(temp.contains(nums[i])) continue;
            //对遍历到的数字的操作
            temp.add(nums[i]);
            //递归
            traceBack(nums, temp);
            //撤销递归前的操作
            temp.remove(temp.size() - 1);
        }

    }
    public List<List<Integer>> permute(int[] nums) {
        List<Integer> temp = new ArrayList<>();
        traceBack(nums, temp);
        return ans;
    }
}