回溯法,一般可以解决如下几种问题:
- 组合问题:N个数里面按一定规则找出k个数的集合;
- 切割问题:一个字符串按一定规则有几种切割方式;
- 子集问题:一个N个数的集合里有多少符合条件的子集;
- 排列问题:N个数按一定规则全排列,有几种排列方式;
- 棋盘问题:N皇后,解数独等等。
回溯法解决的问题都可以抽象为树形结构,所有回溯法的问题都可以抽象为树形结构!因为回溯法解决的都是在集合中递归查找子集,集合的大小就构成了树的宽度,递归的深度就构成了树的深度。回溯算法模板框架如下:
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择:本层集合中元素(树中节点孩子的数量就是集合的大小)) {
处理节点;
backtracking(路径,选择列表); // 递归
回溯,撤销处理结果
}
}
class Solution {
public:
vector<int> path;
vector<vector<int>> res;
vector<vector<int>> combine(int n, int k) {
backtracking(n, k, 1);
return res;
}
void backtracking(int n, int k, int start_index) {
if(path.size() == k){
res.push_back(path);
return;
}
// 还需要的元素个数: k - path.size()
// 集合n中至多要从该起始位置 : n - (k - path.size()) + 1,开始遍历
// 为什么有个+1呢,因为包括起始位置,我们要是一个左闭的集合
for(int i = start_index; i <= n - (k - path.size()) + 1; i++){
path.push_back(i);
backtracking(n, k, i + 1);
path.pop_back();
}
}
};
class Solution {
public:
int sum = 0;
vector<int> path;
vector<vector<int>> res;
vector<vector<int>> combinationSum3(int k, int n) {
backtracking(k, n, 1);
return res;
}
void backtracking(int k, int n, int start_index){
if(sum == n && path.size() == k){
res.push_back(path);
return;
}
// 还需要的元素个数: k - path.size()
// 集合n中至多要从该起始位置 : n - (k - path.size()) + 1,开始遍历
// 为什么有个+1呢,因为包括起始位置,我们要是一个左闭的集合
for(int i = start_index; i <= 9 - (k - path.size()) + 1 && sum < n; i++){
path.push_back(i); sum += i;
backtracking(k, n, i + 1);
path.pop_back(); sum -= i;
}
}
};
class Solution {
public:
string path;
vector<string> res;
vector<string> letterCombinations(string digits) {
if(digits.empty()) return res;
backtracking(digits, 0);
return res;
}
void backtracking(string digits, int index){
if(path.size() == digits.size()){
res.push_back(path);
return;
}
string s = letterMap[digits[index] - '0'];
for(int i = 0; i < s.size(); i++){
path.push_back(s[i]);
backtracking(digits, index + 1);
path.pop_back();
}
}
const string letterMap[10] = {
" ",
"",
"abc",
"def",
"ghi",
"jkl",
"mon",
"pqrs",
"tuv",
"wxyz",
};
};