给你一个 无重复元素 的整数数组 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
输出: []
提示：
1 <= candidates.length <= 30
2 <= candidates[i] <= 40
candidates 的所有元素 互不相同
1 <= target <= 40
回溯算法我们更多的是关注第一次循环，因为我们使用stack保存循环中的数据，当回溯栈中的数据stack.pop()之后循环的规则都是一样的
当前题使用回溯算法，实例1中可以想象一下：
在for循环中
index = 0、 candidates[index] = 2，如果找到了组合总和为 7 - 2 = 5 的所有组合，再在之前加上 2 ，就是 7 的所有组合；
index = 1 candidates[index] = 3，如果找到了组合总和为 7 - 3 = 4 的所有组合，再在之前加上 3 ，就是 7 的所有组合，依次这样找下去。
按照当前的思路我们可以实现第一版：
var combinationSum = function(candidates, target) {
candidates.sort((a, b) => a - b)
let result = []
const dfs = (target, temp) => {
console.log('temp', temp)
if (target < 0) {
return
}
if (target === 0) {
result.push([...temp])
return
}
for (let i=0; i<candidates.length; i++) {
temp.push(candidates[i])
dfs(target-candidates[i], temp)
temp.pop()
}
}
dfs(target, [])
return result
};
//输入
[2,3,6,7]
7
// 输出
[[2,2,3],[2,3,2],[3,2,2],[7]]
但是发现实现之后结果中有重复值，为什么会有重复值呢，我们log一下发现
我们每次循环的开始的index都是从数组的第一项开始的，借用一张图
我们首次循环index=0的时候 会获取值为5的集合，所以在循环index=1的时候，不需要在把index=0放进循环中 所以我们需要在dfs中加一个控制在什么位置循环的变量，更新后的代码
var combinationSum = function(candidates, target) {
candidates.sort((a, b) => a - b)
let result = []
const dfs = (target, temp, begin) => {
console.log('temp', temp)
if (target < 0) {
return
}
if (target === 0) {
result.push([...temp])
return
}
for (let i=begin; i<candidates.length; i++) {
temp.push(candidates[i])
dfs(target-candidates[i], temp, i)
temp.pop()
}
}
dfs(target, [], 0)
return result
};
//输入
[2,3,6,7]
7
// 输出
[[2,2,3],[7]]
我们发现这次的输出结果是正确的，但是我们再看log
我们发现当我们[2, 2, 2, 2]不满足情况后，我们是没有必要再循环后面的，这样会造成性能浪费，所以我们需要控制不必要的循环执行，这也就是剪枝
更新后的代码：
var combinationSum = function(candidates, target) {
candidates.sort((a, b) => a - b)
let result = []
const dfs = (target, temp, begin) => {
console.log('temp', temp)
if (target < 0) {
return
}
if (target === 0) {
result.push([...temp])
return
}
for (let i=begin; i<candidates.length; i++) {
const value = target - candidates[i]
// 当前位置是控制不必要的循环，剪枝
if(value < 0) {
break
}
temp.push(candidates[i])
dfs(target-candidates[i], temp, i)
temp.pop()
}
}
dfs(target, [], 0)
return result
};
//输入
[2,3,6,7]
7
// 输出
[[2,2,3],[7]]
我们再看log:
此时我们的这道题就没问题了。
注意：
递归本身很难理解，所以我们在写递归的时候只需要关注
- 确定函数的参数和返回值
- 确定回溯终止条件
- 确定单层搜索的过程
