39.Combination Sum

题目链接：https://leetcode.com/problems/combination-sum/description/

题目大意：给出一串数字（没有重复数字）和一个数字，找出所有组合数的和与这个数字相等的组合数，其中组合数的每一个数字可以重复选，例子如下：

法一：利用78题的法一，只是这里对target有所限制，还要注意可以重复取数字。代码如下（耗时23ms）：

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        List<Integer> tmp = new ArrayList<Integer>();
        dfs(res, tmp, candidates, target, 0);
        return res;
    }
    public static void dfs(List<List<Integer>> res, List<Integer> tmp, int[] candidates, int target, int start) {
        if(target == 0) {//递归结束条件
            res.add(new ArrayList<Integer>(tmp));
            return;
        }
        else if(target > 0){//这里一定要判断target>0，因为如果不判断就会导致target<0时还在往下递归
            for(int i = start; i < candidates.length; i++) {
                tmp.add(candidates[i]);
                dfs(res, tmp, candidates, target - candidates[i], i);//这里不是i+1而是i，因为可以重复选
                tmp.remove(tmp.size() - 1);
            }
        }
    }

剪枝，先排序，然后在递归的时候，一旦总和<=0则跳出后面的循环。代码如下（耗时18ms）：

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        List<Integer> tmp = new ArrayList<Integer>();
        Arrays.sort(candidates);//先进行排序
        dfs(res, tmp, candidates, target, 0);
        return res;
    }
    public static boolean dfs(List<List<Integer>> res, List<Integer> tmp, int[] candidates, int target, int start) {
        if(target < 0) {
            return false;
        }
        if(target == 0) {//递归结束条件
            res.add(new ArrayList<Integer>(tmp));
            return false;
        }
        else {//这里一定要判断target>0，因为如果不判断就会导致target<0时还在往下递归
            for(int i = start; i < candidates.length; i++) {
                tmp.add(candidates[i]);
                boolean flag = dfs(res, tmp, candidates, target - candidates[i], i);//这里不是i+1而是i，因为可以重复选
                tmp.remove(tmp.size() - 1);
                //剪枝，因为数组是排好序的，所以一旦总和<=0，那么其后的数字一定会导致当前结果<0，所以可以直接从此跳过后面的循环
                if(flag == false) {
                    break;
                }
            }
        }
        return true;
    }

 另一个方法剪枝，不用等到总和<=0才剪枝，而是在dfs之前就判断是否能选该数，否则就跳出循环。代码如下（耗时15ms）：

    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        List<Integer> tmp = new ArrayList<Integer>();
        Arrays.sort(candidates);
        dfs(res, tmp, candidates, target, 0);
        return res;
    }
    public static void dfs(List<List<Integer>> res, List<Integer> tmp, int[] candidates, int target, int start) {
        if(target == 0) {//递归结束条件
            res.add(new ArrayList<Integer>(tmp));
            return;
        }
        else if(target > 0){//这里一定要判断target>0，因为如果不判断就会导致target<0时还在往下递归
            for(int i = start; i < candidates.length; i++) {
                //快速剪枝
                if(target < candidates[i]) {
                    break;
                }
                tmp.add(candidates[i]);
                dfs(res, tmp, candidates, target - candidates[i], i);//这里不是i+1而是i，因为可以重复选
                tmp.remove(tmp.size() - 1);
            }
        }
    }