Leetcode-day21-回溯

39.组合总和

这道题与之前的不同：数组中的元素可以重复出现。

其实有了前面题目的铺垫，这道题很容易可以把以下内容写出来。

还是之前的思路，组合问题走回溯，抽象成树，横向遍历for循环，纵向遍历走递归，叶子节点就是答案

这里的叶子节点如果说总和找到了，加入path然后返回，如果是sum已经比Target大了，那直接返回。

下面答案写完之后其实就差最后一步了，去重。下面答案做出来是排列的，题目要求是组合。 

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {   
    backTracking(candidates,target);
    return res;
    }
    void backTracking(int[] candidates,int target){
        int sum = 0;
        for(int i : path){
            sum+=i;
        }
        if(sum>target){
            return;
        }
        if(target == sum){
            res.add(new ArrayList(path));
            return;
        }
        for(int i=0;i<candidates.length;i++){
            path.add(candidates[i]);
            backTracking(candidates,target);
            path.remove(path.size()-1);
        }
    }
}

```

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {   
    backTracking(candidates,target);
    return res;
    }
    void backTracking(int[] candidates,int target){
        int sum = 0;
        for(int i : path){
            sum+=i;
        }
        if(sum>target){
            return;
        }
        if(target == sum){
            res.add(new ArrayList(path));
            return;
        }
        for(int i=0;i<candidates.length;i++){
            path.add(candidates[i]);
            backTracking(candidates,target);
            path.remove(path.size()-1);
        }
    }
}

```

去重其实最简单的直接调api排序之后去重就行

    List<List<Integer>> result = new ArrayList<>();
    for(List<Integer> temp : res){
        Collections.sort(temp);
        if(!result.contains(temp)){
            result.add(temp);
        }
    }
    return result;

下面是用的startIndex来控制组合中的重复问题，注意递归的时候传入的是i，不是i+1，之前i+1是本元素只能用一次，这次的不限制。

```

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {   
    backTracking(candidates,target,0);
    return res;
    }
    void backTracking(int[] candidates,int target,int startIndex){
        int sum = 0;
        for(int i : path){
            sum+=i;
        }
        if(sum>target){
            return;
        }
        if(target == sum){
            res.add(new ArrayList(path));
            return;
        }
        for(int i=startIndex;i<candidates.length;i++){
            path.add(candidates[i]);
            backTracking(candidates,target,i);
            path.remove(path.size()-1);
        }
    }
}

```