39. 组合总和【回溯】

39. 组合总和

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

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates中的数字可以无限制重复被选取。

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

示例 1：
输入：candidates = [2,3,6,7], target = 7,
所求解集为：[[7],[2,2,3]]

示例 2：
输入：candidates = [2,3,5], target = 8,
所求解集为：[[2,2,2,2],[2,3,3],[3,5]]

思路：
本题和77. 组合、216.组合总和III和区别是：本题没有数量要求，可以无限重复，但是有总和的限制，所以间接的也是有个数的限制。

本题搜索的过程抽象成树形结构如下：

注意图中叶子节点的返回条件，因为本题没有组合数量要求，仅仅是总和的限制，所以递归没有层数的限制，只要选取的元素总和超过target，就返回！

而在77. 组合、216.组合总和III中都可以知道要递归K层，因为要取k个元素的组合。

回溯三部曲：
* 递归函数参数
这里依然是定义两个全局变量，集合result存放结果集，集合path存放符合条件的结果。（这两个变量可以作为函数参数传入）

首先是题目中给出的参数，集合candidates, 和目标值target。

此外我还定义了int型的sum变量来统计单一结果path里的总和，其实这个sum也可以不用，用target做相应的减法就可以了，最后如何target==0就说明找到符合的结果了，但为了代码逻辑清晰，我依然用了sum。

本题还需要idx来控制for循环的起始位置，对于组合问题，什么时候需要idx呢？

如果是一个集合来求组合的话，就需要idx，例如：77. 组合、216.组合总和III。

如果是多个集合取组合，各个集合之间相互不影响，那么就不用idx，例如：17.电话号码的字母组合。

代码如下：

```
List<List<Integer>> result;
List<Integer> path;
void backtracking(List<List<Integer>> result,List<Integer> path,int[] candidates, int target, int sum, int idx)
```

* 递归终止条件
在如下树形结构中：

从叶子节点可以清晰看到，终止只有两种情况，sum大于target和sum等于target。
sum等于target的时候，需要收集结果，代码如下：

```
if (sum > target) {
    return;
}
if (sum == target) {
    result.add(new ArrayList<>(path));
    return;
}
```

* 单层搜索的逻辑

单层for循环依然是从idx开始，搜索candidates集合。

注意本题和77. 组合、216.组合总和III的一个区别是：本题元素为可重复选取的。

如何重复选取呢，看代码，注释部分：

```
for (int i = idx; i < candidates.length; i++) {
    sum += candidates[i];
    path.add(candidates[i]);
    backtracking(result,path,candidates, target, sum, i); // 关键点:不用i+1了，表示可以重复读取当前的数
    sum -= candidates[i];   // 回溯
    path.remove(path.size()-1);        // 回溯
}
```

整体代码如下：

class Solution {

    public List<List<Integer>> combinationSum(int[] candidates, int target) {

        List<List<Integer>> res = new ArrayList<>();

        Arrays.sort(candidates);// 先进行排序

        backtracking(res,new ArrayList<>(),candidates,target,0,0);

        return res;

    }

    public void backtracking(List<List<Integer>> res,List<Integer> path,int[] candidates,int target,int sum,int idx){

        // 找到了数字和为 target 的组合

        if(sum == target){

            res.add(new ArrayList<> (path));

            return ;

        }

        for(int i=idx;i<candidates.length;i++){

            // 如果 sum + candidates[i] > target 就终止遍历

            if(sum+candidates[i]>target){

                break;

            }

            path.add(candidates[i]);

            backtracking(res,path,candidates,target,sum+candidates[i],i);

            // 回溯，移除路径 path 最后一个元素

            path.remove(path.size()-1);

        }

    }

}