前言
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;
}
};
此题难在剪枝