题目:
Given an array of distinct integers candidates
and a target integer target
, return a list of all unique combinations of candidates
where the chosen numbers sum to target
. You may return the combinations in any order.
The same number may be chosen from candidates
an unlimited number of times. Two combinations are unique if the frequency of at least one of the chosen numbers is different.
It is guaranteed that the number of unique combinations that sum up to target
is less than 150
combinations for the given input.
Example 1:
Input: candidates = [2,3,6,7], target = 7 Output: [[2,2,3],[7]] Explanation: 2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times. 7 is a candidate, and 7 = 7. These are the only two combinations.
Example 2:
Input: candidates = [2,3,5], target = 8 Output: [[2,2,2,2],[2,3,3],[3,5]]
Example 3:
Input: candidates = [2], target = 1 Output: []
Constraints:
1 <= candidates.length <= 30
1 <= candidates[i] <= 200
- All elements of
candidates
are distinct. 1 <= target <= 500
思路:
这里同一个数字可以无限重复,那么我们在下一次递归的时候,注意送进去的index是 i 而不是 i + 1即可。这里做了一个剪枝,只有target - 当前数字大于等于0才会进行下一次递归,否则说明当前数字太大了,就没必要往下走了。
代码:
class Solution {
public:
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
backtracking(candidates, target, 0);
return res;
}
private:
vector<vector<int>> res;
vector<int> path;
void backtracking(vector<int>& candidates, int target, int cur) {
if (target == 0) {
res.push_back(path);
return;
}
for (int i = cur; i < candidates.size(); i++) {
if (target - candidates[i] >= 0) {
path.push_back(candidates[i]);
backtracking(candidates, target - candidates[i], i);
path.pop_back();
}
}
}
};