回溯算法
LeetCode 77 组合
题目描述
思路
- 递归函数的返回值以及参数
在这里要定义两个全局变量，一个用来存放符合条件单一结果，一个用来存放符合条件结果的集合。
代码如下：
vector<vector<int>> result; // 存放符合条件结果的集合
vector<int> path; // 用来存放符合条件结果从下图中红线部分可以看出，在集合[1,2,3,4]取1之后，下一层递归，就要在[2,3,4]中取数了，通过在每一次递归中调整startindex的值，在2,3,4中取数。
那么整体代码如下：
vector<vector<int>> result; // 存放符合条件结果的集合
vector<int> path; // 用来存放符合条件单一结果
void backtracking(int n, int k, int startIndex)
- 回溯函数终止条件
path这个数组的大小如果达到k，说明我们找到了一个子集大小为k的组合了，此时用result二维数组，把path保存起来，并终止本层递归。
如图红色部分：
所以终止条件代码如下：
if (path.size() == k) {
result.push_back(path);
return;
}- 单层搜索的过程
for循环用来横向遍历，递归的过程是纵向遍历。for循环通过横向遍历，分别取1，2，3，4。递归通过改变startindex的值，纵向遍历。
如此我们才遍历完图中的这棵树。
for循环每次从startIndex开始遍历，然后用path保存取到的节点i。
代码如下：
for (int i = startIndex; i <= n; i++) { // 控制树的横向遍历
path.push_back(i); // 处理节点
backtracking(n, k, i + 1); // 递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
path.pop_back(); // 回溯，撤销处理的节点
}代码实现
class Solution {
public:
vector<vector<int>> result;
vector<int> path;
void backtracking(int n,int k,int startindex){
if(path.size() == k){
result.push_back(path);
return;
}
for(int i = startindex;i <= n;i++){
path.push_back(i);
backtracking(n,k,i+1);
path.pop_back();
}
}
vector<vector<int>> combine(int n, int k) {
backtracking(n,k,1);
return result;
}
};剪枝优化
上一题中，我们需要遍历n的所有取值，但是有些时候我们并不需要把这几个数全部都试一遍，来举一个例子，n = 4，k = 4的话，那么第一层for循环的时候，从元素2开始的遍历都没有意义了。 在第二层for循环，从元素3开始的遍历都没有意义了。
从77题我们可以知道for循环是进行横向遍历的，所以我们只需要改变横向遍历的范围即可，那将范围更改到什么数值呢，应该更改到startindex到n-(k-path.size())+1，k-path.size()是目前还需要加入组合的数量，如果还需要三个数字加入组合，那么就需要从index为1的数字搜索，也就是n-(k-path.size())+1
LeetCode 216 组合总和
题目描述
找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：
- 只使用数字1到9
- 每个数字 最多使用一次
返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。
示例 1:
输入: k = 3, n = 7 输出: [[1,2,4]] 解释: 1 + 2 + 4 = 7 没有其他符合的组合了。
示例 2:
输入: k = 3, n = 9 输出: [[1,2,6], [1,3,5], [2,3,4]] 解释: 1 + 2 + 6 = 9 1 + 3 + 5 = 9 2 + 3 + 4 = 9 没有其他符合的组合了。
示例 3:
输入: k = 4, n = 1 输出: [] 解释: 不存在有效的组合。 在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。
思路
这道题与77题第一个不同的地方在于终止条件，多了一个要判断总和是否与要求的一致，接下来进入for循环，要更新目前的sum的值，在i被存进数组的时候，将i加进sum，去比较总和是否符合条件，比较完之后，再将i从sum中减去。
代码实现
class Solution {
public:
vector<vector<int>> result;
vector<int> path;
void backtracking(int k,int n,int sum,int startindex){
if(path.size() == k){
if(sum == n){
result.push_back(path);
}
return;
}
for(int i = startindex;i <= 9;i++){
path.push_back(i);
sum += i;
backtracking(k,n,sum,i+1);
path.pop_back();
sum -= i;
}
}
vector<vector<int>> combinationSum3(int k, int n) {
int sum = 0;
backtracking(k,n,sum,1);
return result;
}
};LeetCode17 电话号码的字母组合
题目描述
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
示例 1：
输入：digits = "23" 输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]
示例 2：
输入：digits = "" 输出：[]
示例 3：
输入：digits = "2" 输出：["a","b","c"]
思路
- 确定回溯函数参数
首先需要一个字符串s来收集叶子节点的结果，然后用一个字符串数组result保存起来，这两个变量我依然定义为全局。
本题中的参数除了题目中给的string digits，然后还要有一个参数就是int型的index。这个index代表的不是77题中的startindex，因为这次题目中遍历的是两个集合，所以不需要startindex去调整从哪里开始遍历元素。
这个index是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。
代码如下：
vector<string> result;
string s;
void backtracking(const string& digits, int index)
- 确定终止条件
例如输入用例"23"，两个数字，那么根节点往下递归两层就可以了，叶子节点就是要收集的结果集。
那么终止条件就是如果收集结果的字符串s的大小等于输入的数字个数digits.size了。
然后收集结果，结束本层递归。
代码如下：
if (index == digits.size()) {
result.push_back(s);
return;
}
- 确定单层遍历逻辑
首先要根据index，转换成需要遍历的字符串，字符串在digits中，通过映射将digits中的数字，转换成我们需要遍历的字符串。还需要注意的点是这里的i是从0开始，而不是从startindex开始，因为遍历两个集合都是从第0个元素。
然后for循环来处理这个字符集，代码如下：
int digit = digits[index] - '0'; // 将index指向的数字转为int
string letters = letterMap[digit]; // 取数字对应的字符集
for (int i = 0; i < letters.size(); i++) {
s.push_back(letters[i]); // 处理
backtracking(digits, index + 1); // 递归，注意index+1，一下层要处理下一个数字了
s.pop_back(); // 回溯
}代码实现
class Solution {
public:
const string letterMap[10] = {
"", // 0
"", // 1
"abc", // 2
"def", // 3
"ghi", // 4
"jkl", // 5
"mno", // 6
"pqrs", // 7
"tuv", // 8
"wxyz", // 9
};
vector<string> result;
string s;
void backtracking(const string& digits, int index) {
if (s.size() == digits.size()) {
result.push_back(s);
return;
}
int digit = digits[index] - '0';
string letter = letterMap[digit];
for(int i = 0;i <= letter.size() - 1;i++){
s.push_back(letter[i]);
backtracking(digits,index + 1);
s.pop_back();
}
}
vector<string> letterCombinations(string digits) {
if(digits.size() == 0){
return result;
}
backtracking(digits,0);
return result;
}
};
