（回溯法）解决一系列组合问题

题目一：

Given two integers n and k, return all possible combinations of k numbers out of 1 ... n.

For example,
If n = 4 and k = 2, a solution is:

[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

给你两个整数 n和k，从1-n中选择k个数字的组合。比如n=4，那么从1,2,3,4中选取两个数字的组合

　　解题思路：http://www.cnblogs.com/Kobe10/p/6361336.html

题目二：

Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

The same repeated number may be chosen from C unlimited number of times.

Note:

All numbers (including target) will be positive integers.
Elements in a combination (a1, a2, … , ak) must be in non-descending order. (ie, a1 ≤ a2 ≤ … ≤ ak).
The solution set must not contain duplicate combinations.

For example, given candidate set2,3,6,7and target7,
A solution set is:
[7]
[2, 2, 3]

给你一个正数数组candidate[],一个目标值target，寻找里面所有的不重复组合，让其和等于target，给你[2,3,6,7] 2+2+3=7 ,7=7,所以可能组合为[2,2,3],[7]）

　　解题思路：http://www.cnblogs.com/Kobe10/p/6361336.html

题目三：

给定候选数字（C）和目标数字（T）的集合，找到C中的所有唯一组合，其中候选数字总计为T.

C中的每个数字只能在组合中使用一次。

注意：

所有数字（包括目标）将是正整数。
组合（a1，a2，...，ak）中的元素必须以非降序排列。 （即，a 1≤a2≤...≤ak）。
解集必须不包含重复组合。

例如，给定候选集10,1,2,7,6,1,5和target8，
解决方案集是：
[1,7]
[1,2,5]
[2,6]
[1,1,6]

思路：这个题目和第二题是一个类型的题目，但是他要求的是出现的组合中不能出现重复的数字。所以就要设置一个剪枝函数来限制出现重复的元素，对每一个进入的元素进行判断，看当前元素是否等于上一个元素（因为是递增的关系，所以只要比较上一个元素即可），如果等于就跳过这个元素，继续进行运算。

代码

class Solution {
public:
vector<vector<int> > res;
vector<vector<int> > combinationSum2(vector<int> &num, int target) {
vector<vector<int> > res;
sort(num.begin(),num.end());
vector<int> temp;
backtrack(res,num,temp,target,0);
return res;
}
void backtrack(vector<vector<int> > &res,vector<int> &candidates, vector<int> &temp,int target,int start){
if (target < 0)
return;
else if (target == 0){
res.push_back(temp);
return ;
}

for(int i=start;i<candidates.size();i++){
if(i>start && candidates[i]==candidates[i-1])continue;//i>start表示第一次不需要进行判断，之后再进行判断

temp.push_back(candidates[i]);
backtrack(res,candidates,temp,target-candidates[i],i+1);
temp.pop_back();
}

}
};

题目四：

给定一组不同的整数S，返回所有可能的子集。

注意：

子集中的元素必须以非降序排列。
解集必须不包含重复的子集。

例如，
如果S = [1,2,3]，解决方案是：

[
[3]，
[1]，
[2]，
[1,2,3]，
[1,3]，
[2,3]，
[1,2]，
[]
]]

思路：这个题目和第一个题目有点类似。这个题目是数组的所有的组合，而第一题是指定个数的组合数。所以这个是输出所有的，在第一题目的基础上循环输出给定数目的组合数。

代码：

class Solution {
public:
//这道题也是回溯法的套路啊，题目类似于Combinations啊，但是这个是所有的组合，而那个是指定个数的组合，所以只要循环的进行
//回溯就可以实现所有的组合
vector<vector<int> > res;
vector<vector<int> > subsets(vector<int> &S) {
vector<int> temp;
sort(S.begin(), S.end());
for (int i=0; i<=S.size(); i++)
backtrack(S, temp, 0, i);
return res;
}
void backtrack(vector<int> &S, vector<int> temp, int start, int k){
if (k < 0)
return ;
else if (k == 0)
res.push_back(temp);
else{
for (int i=start; i<S.size(); i++){
temp.push_back(S[i]);
backtrack(S, temp, i+1, k-1);
temp.pop_back();
}
}
}
};

题目五：

给定一个可能包含重复S的整数集合，返回所有可能的子集。

注意：

子集中的元素必须按照降序排列。
解集必须不包含重复的子集。

例如，
如果S = [1,2,2]，解决方案是：

[
[2]，
[1]，
[1,2,2]，
[2,2]，
[1,2]，
[]
]]

思路：这里加上了重复的元素，所以直接处理看前后两个元素是否相等。如果相等就跳过这个元素。
　　　　

代码：

class Solution {
public:
vector<vector<int> > res;
vector<vector<int> > subsetsWithDup(vector<int> &S) {
vector<int> temp;
sort(S.begin(), S.end());
for (int i=0; i<=S.size(); i++)
backtrack(S, temp, 0, i);
return res;
}
void backtrack(vector<int> &S, vector<int> temp, int start, int k){
if (k < 0)
return ;
else if (k == 0)
res.push_back(temp);
else{
for (int i=start; i<S.size(); i++){
if (i>start && S[i] == S[i-1])
continue;
temp.push_back(S[i]);
backtrack(S, temp, i+1, k-1);
temp.pop_back();
}
}
}
};