leetcode关于“组合“的题目合集
最近做leetcode每日一题，连续三四天都做到一个主题，叫做“组合”，核心算法思想是 回溯法，跟子集、子集II、全排列、路径规划等思想较为相似，这里做一个记录。
77. 组合
给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。
示例:
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]
39.组合总数
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。
说明：
所有数字（包括 target）都是正整数。
解集不能包含重复的组合。
示例 1：
输入：candidates = [2,3,6,7], target = 7,
所求解集为：
[
[7],
[2,2,3]
]
提示：candidate 中的每个元素都是独一无二的。
40.组合总数II
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
说明：
所有数字（包括目标数）都是正整数。
解集不能包含重复的组合。
示例 1:
输入: candidates = [10,1,2,7,6,1,5], target = 8,
所求解集为:
[
[1, 7],
[1, 2, 5],
[2, 6],
[1, 1, 6]
]
216 组合总数III
找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
说明：
所有数字都是正整数。
解集不能包含重复的组合。
示例 1:
输入: k = 3, n = 7
输出: [[1,2,4]]
示例 2:
输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
这几道题的核心思想都是回溯+剪枝，对这几道题做一个归纳，大概如下：
77.组合
数组无重复数字，规定每个组合的元素个数为k。
直接进行深搜+边界剪枝即可。
class Solution {
public:
vector<int> temp;
vector<vector<int>> ans;
void dfs(int cur, int n, int k) {
// 剪枝：temp 长度加上区间 [cur, n] 的长度小于 k，不可能构造出长度为 k 的 temp
if (temp.size() + (n - cur + 1) < k) {
return;
}
// 记录合法的答案
if (temp.size() == k) {
ans.push_back(temp);
return;
}
/* 这种写法也可以，下面采用循环，不过需要注意循环起点不能是0，因为这里不是求全排列，而就是单纯选取当前的数
// 考虑选择当前位置
temp.push_back(cur);
dfs(cur + 1, n, k);
temp.pop_back();
// 考虑不选择当前位置
dfs(cur + 1, n, k);
*/
for(int i = cur; i <= n; ++i){
temp.push_back(i);
dfs(i + 1, n, k);
temp.pop_back();
}
}
vector<vector<int>> combine(int n, int k) {
dfs(1, n, k);
return ans;
}
};
39.组合总数
每个数字可以任意选取，数组中无重复元素。
同样由于无重复元素，故直接深搜即可。
dfs(candidates, i, target, cursum + candidates[i]);
这里不需要i + 1，因为每个数字可任意选取。
class Solution {
public:
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
if(candidates.size() <= 0){
return res;
}
dfs(candidates, 0, target, 0);
return res;
}
void dfs(vector<int>& candidates, int begin, int target, int cursum){
if(target == cursum){
res.emplace_back(temp);
return;
}
for(int i = begin; i < candidates.size(); ++i){
if(cursum + candidates[i] <= target){
temp.emplace_back(candidates[i]);
//注意这里不是i + 1，因为每个元素可以被重复利用*
dfs(candidates, i, target, cursum + candidates[i]);
temp.pop_back();
}
}
}
private:
vector<vector<int>> res;
vector<int> temp;
};
40.组合总数II
每个数字只能使用一次，解集不能包含重复的组合。
为了避免重复，首先我们可以先对源数组排序，排序的目的就是为了避免紧挨着两个相同的元素(nums[i]和nums[i-1])被重复使用，然后当前使用过的元素下一次就不能再次使用。
class Solution {
public:
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
if(candidates.size() <= 0){
return res;
}
sort(candidates.begin(), candidates.end());
dfs(candidates, 0, 0, target);
return res;
}
void dfs(vector<int>& nums, int begin, int cursum, int target){
if(cursum == target){
res.emplace_back(temp);
return;
}
for(int i = begin; i < nums.size(); ++i){
//由于事先排序好了，这里直接去重即可。
if(cursum + nums[i] <= target){
if(i > begin && nums[i] == nums[i - 1]){
continue;
}
temp.emplace_back(nums[i]);
dfs(nums, i + 1, cursum + nums[i], target);
temp.pop_back();
}
}
}
private:
vector<vector<int>> res;
vector<int> temp;
};
216.组合总数III
相加和为 n 的 k 个数，只允许包含 1~9，解集不能重复
其实也是一样的，这个更简单一些，对于每个当前数字而言，下一个数字可以选择当前数字之后的数字，也不需要排序了，并且源数组直接就是1~9，在1 - 9进行选择即可。
class Solution {
public:
vector<vector<int>> combinationSum3(int k, int n) {
if(k <= 0){
return vector<vector<int>>();
}
// 1. 不能存在重复的数
dfs(1, 0, n, k);
return res;
}
void dfs(int begin, int cursum, int n, int k){
if(cursum >= n && temp.size() == k){
if(n == cursum){
res.emplace_back(temp);
}
return;
}
//题目说元素只能是1~9, 所以可以不需要nums, 直接循环
for(int i = begin; i < 10; ++i){
//从begin开始, 一直往后搜索，直到满足退出条件。
if(cursum + i <= n){
temp.emplace_back(i);
dfs(i + 1, cursum + i, n, k);
temp.pop_back(); //回溯
}
}
}
private:
vector<vector<int>> res;
vector<int> temp;
};