前言
更详细的在大佬的代码随想录 (programmercarl.com)
本系列仅是简洁版笔记，为了之后方便观看
解决的类型问题
组合无序，排列有序
- 组合
- 切割
- 子集
- 排列（强调元素的顺序）
- 棋牌问题（n皇后，数独）
回溯法的三个步骤
- 递归函数参数/返回值
- 终止条件
- 单层递归逻辑
去重词汇
- 树层去重
- 树枝去重
模版
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (遍历结点) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
组合
77. 组合 - 力扣（LeetCode）
class Solution {
private:
vector<vector<int>> result;
vector<int>path;
void backtracking(int n,int k,int a)//a表示递归的层数
{
if(path.size()==k)
{
result.push_back(path);
return;
}
for(int i=a;i<=n;i++)
{
path.push_back(i);
backtracking(n, k, i + 1);
path.pop_back();
}
}
public:
vector<vector<int>> combine(int n, int k) {
backtracking(n,k,1);
return result;
}
};剪枝思路：从for循环开始的起始位置之后选择的元素个数不足需要的元素个数时，无需继续搜索
for (int i = a; i <= n - (k - path.size()) + 1; i++)组合总和III
和上一题整体模版是一样的，主要是多了sum的处理和sum的回溯
216. 组合总和 III - 力扣（LeetCode）
class Solution {
private:
vector<vector<int>>result;
vector<int>path;
void backtracking(int target,int k,int sum,int startIndex)
{
if(sum>target)
{
return;
}
if(path.size()==k)
{
if(sum==target)
result.push_back(path);
return ;
}
for(int i=startIndex;i<=9-(k-path.size())+1;i++)
{
sum += i; // 处理
path.push_back(i); // 处理
backtracking(target, k, sum, i + 1); // 注意i+1调整startIndex
sum -= i; // 回溯
path.pop_back(); // 回溯
}
}
public:
vector<vector<int>> combinationSum3(int k, int n) {
result.clear(); // 可以不加
path.clear(); // 可以不加
backtracking(n, k, 0, 1);
return result;
}
};电话号码的字母组合
17. 电话号码的字母组合 - 力扣（LeetCode）
1.用二维数组来做一个映射
2.对比发现隐藏的回溯
for (int i = 0; i < letters.size(); i++) {
s.push_back(letters[i]);
backtracking(digits, index + 1);
s.pop_back();
}for (int i = 0; i < letters.size(); i++) {
getCombinations(digits, index + 1, s + letters[i]);
// void getCombinations(const string& digits, int index, const string& s)
}第二个是进入到下一层计算了，但是s没有变化，所以就相当于回溯了
class Solution {
private:
const string letterMap[10]={
//逐个映射
"", // 0
"", // 1
"abc", // 2
"def", // 3
"ghi", // 4
"jkl", // 5
"mno", // 6
"pqrs", // 7
"tuv", // 8
"wxyz"//9
};
public:
vector<string>result;
string s;
void backtracking(const string&digits,int index)
{
if (index == digits.size()) {
result.push_back(s);
return;
}
int digit=digits[index] - '0';//依次遍历数字
string letters = letterMap[digit]; //寻找该位置对应的字符串
for (int i = 0; i < letters.size(); i++) {
s.push_back(letters[i]);
backtracking(digits, index + 1);
s.pop_back();
}
}
vector<string> letterCombinations(string digits) {
s.clear();
result.clear();
if (digits.size() == 0) {
return result;
}
backtracking(digits, 0);
return result;
}
};组合总和
39. 组合总和 - 力扣（LeetCode）
1.和之前的组合总和最大的差别就是已经选取过的元素还可以再选取
2.startIndex的作用是：每一次遍历开始的位置，使求出来的组合没有重复元素，例如组合23和组合32
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& candidates, int target, int sum, int startIndex) {
if (sum == target) {
result.push_back(path);
return;
}
for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
sum += candidates[i];
path.push_back(candidates[i]);
backtracking(candidates, target, sum, i);//这儿不用i+1的原因是因为可以重复使用某个数字
sum -= candidates[i];//回溯
path.pop_back();
}
}
public:
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
result.clear();
path.clear();
sort(candidates.begin(), candidates.end()); //从小到大排序，如果组合和大于所要求的值，则后面的数必定大于所要求的值
backtracking(candidates, target, 0, 0);
return result;
}
};组合总和II
原数组有重复元素但结果不能有重复的组合（进行去重操作）
40. 组合总和 II - 力扣（LeetCode）
1.排序的原因：把相邻元素放在一起
2.本题去重关键：
树层去重，如果该层已经取过1了，那么它的同一层就不需要再取了，因为前面的1已经包含了1的所有组合（目的：没有重复的元素组合）
原数组有重复元素
树枝去重是没有必要的，因为一条链上本来就可以取得组合中的所有元素，也包括重复的元素（比如果该集合中有两个1，就可以同时取两个1）
3.相比上一题就是多了个used数组来记录该元素是否被使用过
4.used[i - 1] == false 表示，在同一树层上取的 candidates[i] 是从 candidates[i - 1] 回溯而来的，如果 used[i - 1] == true，就说明是进入下一层递归，去下一个数，就进行树枝上的深入
used[i - 1] == true，说明同一树枝candidates[i - 1]使用过（说明同一条链被用过）
used[i - 1] == false，说明同一树层candidates[i - 1]使用过5.重点回溯代码
if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
continue;
}
