前言
1、回溯法解决的问题都可以抽象为树形结构（N叉树），使用树形结构来理解回溯。
2、回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度，都构成的树的深度。
3、回溯的终止条件，代表这是一棵高度有限的树（N叉树）。
回溯函数终止条件
if (终止条件) {
存放结果;
return;
}
4、回溯的单层递归
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
dfs(路径，选择列表); // 递归
回溯，撤销处理结果
}
总结
void dfs(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
dfs(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
组合问题
0 17 电话号码的字母组合
此题与其他组合题不同，一般的组合题每层的选择的东西要么越来越少（使用startIndex），要么可以重复选择相同的元素（每次都是从0开始）。
但是该题不需要startIndex，而每层选择的东西都可能是不同的（因为按键不同，根据按键选择需要的东西），所以这个每次也是从0开始，但是遍历的是不同的字符串。
1、数字和字母如何映射
2、输入1 * #按键等等异常情况（力扣上没考虑）
每层可以选3或4个字母，树的深度为合法按键个数
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> res;
string path;
void dfs(string& digits, int index){
if(index == digits.size()) {
res.push_back(path);
return;
}
int key = digits[index] - '0';
string zimu = letterMap[key];
for(int i = 0; i < zimu.size(); ++i){
path.push_back(zimu[i]);
dfs(digits, index+1);
path.pop_back();
}
}
vector<string> letterCombinations(string digits) {
if (digits.size() == 0) return res;
dfs(digits, 0);
return res;
}
};
1 77 组合
输出一个二维数组，所以操作的是一个一维数组path，和结果二维数组res
1、退出条件
当path的长度等于k了之后，则退出这个递归，这个时候会在单层逻辑中回溯一次，回到第二层
if(path,size() == k){
res.push_back(path);
return;
}
2、单层递归逻辑
这里面包含了两层逻辑，一层深入逻辑（递归），一层遍历逻辑（for）。
其中bfs中的第三个参数i + 1为了不去取重复的值。
其中的回溯部分，有bfs函数被return时的单次回溯，也存在与for循环结束时的两次回溯，之后会退回第一层循环
for(int i = startIndex; i <= n; ++i){
path.push_back(i);
dfs(n, k, i + 1);
path.pop_back();
}
3、整体函数
vector<vector<int>> result; // 存放符合条件结果的集合
vector<int> path; // 用来存放符合条件结果
void dfs(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);
dfs(n, k, i + 1);
path.pop_back();
}
}
2 77 组合优化
剪枝优化：当n = 4(四个数供选择),k = 4(四个数组合)，则很多枝杈是无需遍历的，如上图，所谓剪枝即将无需遍历的枝杈除去。
for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) { // i为本次搜索的起始位置
...
}
3 216 组合总和III
1和2组合的同类型题
无剪枝
一开始并没有想到要将sum作为参数传进回溯函数中，写到最后发现
class Solution {
public:
vector<int> path;
vector<vector<int>> res;
void dfs(int k, int n, int startIndex, int sum){
if(path.size() == k && sum == n){
res.push_back(path);
return;
}
// int sum = 0;
for(int i = startIndex; i <= 9; ++i){
sum += i;
path.push_back(i);
dfs(k, n, i + 1, sum);
sum -= i;
path.pop_back();
}
}
vector<vector<int>> combinationSum3(int k, int n) {
dfs(k, n, 1, 0);
return res;
}
};
剪枝
如果已选元素总和如果已经大于n了，那么往后遍历就没有意义了，直接剪掉。
于是在dfs开头return即可
if (sum > targetSum) { // 剪枝
return;
}
当然还有观察节点数够不够的for循环继续条件内的剪枝
for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) { // i为本次搜索的起始位置
...
}
4 39 组合总和
此题与3题不同之处在于他可以重复选取元素，相同之处在于他所提供candidates候选数组中没有重复的元素。
要注重理清
1、 for循环的退出条件是什么
2、 startIndex怎么取
1、回溯退出条件
if (sum > target) {
return;
}
if (sum == target) {
result.push_back(path);
return;
}
2、for循环
dfs的输入不用 i+1 很关键，for循环的退出条件不用改变，startIndex也需要使用（防止重复结果）
for (int i = startIndex; i < candidates.size(); i++) {
sum += candidates[i];
path.push_back(candidates[i]);
dfs(candidates, target, sum, i); // 关键点:不用 i+1 了，表示可以重复读取当前的数
sum -= candidates[i]; // 回溯
path.pop_back(); // 回溯
}
3、输入
void dfs(vector<int> candidates, int target, int sum, int startIndex)
5 40 组合总和II
此题与4题完全不同，该题不可以重复选取元素，所提供candidates候选数组中有重复的元素。
如果直接使用前面3题4题的思路，得到的答案如下所示，可以看出有[1,2,5]和[2,1,5]重复（candidates有中两个1，所以1被多选了）
所以有两个条件很关键
1、同一个for循环内相同两个重复元素不可以重复选
2、因为递归而深入的for循环可以重复选相同元素（建立在startIndex + 1的情况）
1、回溯退出条件与4相同
2、单层for循环逻辑
要去重的是“同一for循环中的使用过元素”，如何判断同一for循环上元素（相同的元素）是否使用过了？
if(candidates[i] == candidates[i-1]) continue;
注意：需要先对数组进行排序再判断重复：sort(candidates.begin(), candidates.end());
代码如下：
for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
// 要对同一树层使用过的元素进行跳过
if (i > startIndex && candidates[i] == candidates[i - 1]) {
continue;
}
sum += candidates[i];
path.push_back(candidates[i]);
backtracking(candidates, target, sum, i + 1); // 和39.组合总和的区别1，这里是i+1，每个数字在每个组合中只能使用一次
sum -= candidates[i];
path.pop_back();
}
3、输入与4题相同
4、整合
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void dfs(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++) {
// 要对同一树层使用过的元素进行跳过
if (i > startIndex && candidates[i] == candidates[i - 1]) {
continue;
}
sum += candidates[i];
path.push_back(candidates[i]);
backtracking(candidates, target, sum, i + 1); // 和39.组合总和的区别1，这里是i+1，每个数字在每个组合中只能使用一次
sum -= candidates[i];
path.pop_back();
}
}
public:
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
path.clear();
result.clear();
// 首先把给candidates排序，让其相同的元素都挨在一起。
sort(candidates.begin(), candidates.end());
dfs(candidates, target, 0, 0);
return result;
}
};
6 15 三数之和
class Solution {
public:
vector<int> path;
vector<vector<int>> res;
void dfs(vector<int>& nums, int startIndex, int sum) {
if(sum == 0 && path.size() == 3){
res.push_back(path);
return;
}
for(int i = startIndex; i < nums.size(); ++i){
if(i > startIndex && nums[i] == nums[i-1]) continue;
path.push_back(nums[i]);
sum += nums[i];
dfs(nums, i + 1, sum);
path.pop_back();
sum -= nums[i];
}
}
vector<vector<int>> threeSum(vector<int>& nums) {
sort(nums.begin(), nums.end());
dfs(nums, 0, 0);
return res;
}
};
此题难在剪枝
395
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
