前言
更详细的在大佬的代码随想录 (programmercarl.com)
本系列仅是简洁版笔记，为了之后方便观看
解决的类型问题
组合无序，排列有序
- 组合
- 切割
- 子集
- 排列（强调元素的顺序）
- 棋牌问题（n皇后，数独）
回溯法的三个步骤
- 递归函数参数/返回值
- 终止条件
- 单层递归逻辑
去重词汇
- 树层去重
- 树枝去重
模版
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (遍历结点) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
组合
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的回溯
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;
}
};电话号码的字母组合
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;
}
};组合总和
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
原数组有重复元素但结果不能有重复的组合（进行去重操作）
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;
}子集类问题可以不写终止条件
分割回文串
题目
给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 返回 s 所有可能的分割方案。
思考结果
切割线:startIndex
截取的子串:[startIndex,i]
代码
class Solution {
private:
vector<vector<string>> result;//二维数组
vector<string>path;//定义一维数组
bool istrue(const string&s,int start,int end )//判断是不是回文
{
for(int i=start,j=end;i<j;i++,j--)//双指针法
{
if(s[i]!=s[j]){
return false;
}
}
return true;
}
void backtracking(const string&s,int startIndex){
if(startIndex>=s.size()){//结束条件
result.push_back(path);
return ;
}
for(int i=startIndex;i<s.size();i++){//从分割线开始
if(istrue(s,startIndex, i)){//是回文子串
string str=s.substr(startIndex,i-startIndex+1);//分割串的范围是[startIndex,i]
path.push_back(str);
}
else { // 不是回文，跳过
continue;
}
backtracking(s, i + 1); //i+1为起始位置的回文子串
path.pop_back(); //回溯
}
}
public:
vector<vector<string>> partition(string s) {
result.clear();
path.clear();
backtracking(s, 0);
return result;
}
};复原IP地址
pointNum记录逗号数量，pointNum=3说明此时有四个串
i+2的原因是在字符串中加入了分隔符
.
class Solution {
private:
vector<string>result;
void backtracking( string& s,int startIndex,int pointnum){
if(pointnum==3){
if(isvalid(s,startIndex,s.size()-1)){
result.push_back(s);
return ;
}
}
for (int i = startIndex; i < s.size(); i++) {
if (isvalid(s, startIndex, i)) {
s.insert(s.begin() + i + 1 , '.');
pointnum++;
backtracking(s, i + 2, pointnum);
pointnum--;
s.erase(s.begin() + i + 1);
}else break;
}
}
bool isvalid(const string& s, int start, int end) {
if (start > end) {
return false;
}
if (s[start] == '0' && start != end) {
return false;
}
int num = 0;
for (int i = start; i <= end; i++) {
if (s[i] > '9' || s[i] < '0') {
return false;
}
num = num * 10 + (s[i] - '0');
if (num > 255) {
return false;
}
}
return true;
}
public:
vector<string> restoreIpAddresses(string s) {
result.clear();
if(s.size()<4||s.size()>12) return result;
backtracking(s,0,0);
return result;
}
};子集
不同点：和之前学过的例子相比较，每一层递归里面都有自己需要的结果
终点状态：剩余集合是空集合
终止条件可以不加:因为如果大于了数组的大小，for循环不会进入进去，直接return
注意：把收获结果放在终止条件之前，不然会省略掉最后的结果
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex) {
result.push_back(path);
if (startIndex >= nums.size())
{
return;
}
for (int i = startIndex; i < nums.size(); i++) {
path.push_back(nums[i]);
backtracking(nums, i + 1);
path.pop_back();
}
}
public:
vector<vector<int>> subsets(vector<int>& nums) {
result.clear();
path.clear();
backtracking(nums, 0);
return result;
}
};子集II
原集合有重复元素但不能有重复子集
去重步骤：先排序，树层去重，树枝上不去重
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
continue;
} bool数组定义
vector<bool> used(nums.size(), false);总代码
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
result.push_back(path);
for (int i = startIndex; i < nums.size(); i++) {
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
continue;
}
path.push_back(nums[i]);
used[i] = true;
backtracking(nums, i + 1, used);
used[i] = false;
path.pop_back();
}
}
public:
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
result.clear();
path.clear();
vector<bool> used(nums.size(), false);
sort(nums.begin(), nums.end());
backtracking(nums, 0, used);
return result;
}
};子集、组合、分割问题的的区别
子集：收集树形结构中树的所有节点的结果。
组合、分割问题：收集树形结构中叶子节点的结果。
递增子序列
给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。
排序做法不可取：改变了元素的顺序
去重+非递减
unordered_set<int> uset;
if ((!path.empty() && nums[i] < path.back())|| uset.find(nums[i]) != uset.end())
{
continue;
}总代码
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex) {
if (path.size() > 1) {//题意说大小要大于2
result.push_back(path);
}//不加return，因为它也属于子集问题
unordered_set<int> used; // 每一次递归都要记录 仅是对于本层进行去重
for (int i = startIndex; i < nums.size(); i++) {
if ((!path.empty() && nums[i] < path.back())|| used.find(nums[i]) !=used.end())
continue;
used.insert(nums[i]); //本层已经用过该元素了
path.push_back(nums[i]);//添加元素
backtracking(nums, i + 1);//递归到下一层
path.pop_back();//返回
}
}
public:
vector<vector<int>> findSubsequences(vector<int>& nums) {
backtracking(nums, 0);
return result;
}
};全排列
used是标记该元素是否被用过
for循环从0开始不从之前的startIndex开始是因为排列讲究顺序，[1,2]和[2,1]是两种情况
class Solution {
public:
vector<vector<int>>result;
vector<int>path;
void backtracking(vector<int>& nums, vector<bool>& used){
if(path.size()==nums.size()){
result.push_back(path);
return;
}
for(int i=0;i<nums.size();i++){
if(used[i]==true) continue;
used[i]=true;
path.push_back(nums[i]);
backtracking(nums, used);
path.pop_back();
used[i] = false;
}
}
vector<vector<int>> permute(vector<int>& nums) {
result.clear();
path.clear();
vector<bool> used(nums.size(), false);
backtracking(nums, used);
return result;
}
};全排列II
和上面的代码区别不大
区别：
1.在for循环中加入下面的语句
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false)
{
continue;
}2.在主函数中要先排序
sort(nums.begin(), nums.end()); N皇后
class Solution {
private:
vector<vector<string>>result;
void backtracking(int n,int row,vector<string>& chessboard){
if(row==n){
result.push_back(chessboard);
return ;
}
for(int col=0;col<n;col++){
if(isvalid(row,col,chessboard,n)){
chessboard[row][col]='Q';
backtracking(n,row+1,chessboard);
chessboard[row][col]='.';
}
}
}
bool isvalid(int row,int col,vector<string>& chessboard,int n){
for (int i = 0; i < row; i++) { // 这是一个剪枝
if (chessboard[i][col] == 'Q') {
return false;
}
}
// 检查 45度角是否有皇后
for (int i = row - 1, j = col - 1; i >=0 && j >= 0; i--, j--) {
if (chessboard[i][j] == 'Q') {
return false;
}
}
// 检查 135度角是否有皇后
for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
if (chessboard[i][j] == 'Q') {
return false;
}
}
return true;
}
public:
vector<vector<string>> solveNQueens(int n) {
result.clear();
vector<string> chessboard(n, string(n, '.'));
backtracking(n, 0, chessboard);
return result;
}
};解数独
两个for循环
本题backtracking是bool类型，是因为只需要一个结果
class Solution {
private:
bool backtracking(vector<vector<char>>&board){
for(int i=0;i<board.size();i++){
for(int j=0;j<board[0].size();j++){
if(board[i][j]=='.'){
for(char k='1';k<='9';k++){
if(isvalid(i,j,k,board)){
board[i][j]=k;
if(backtracking(board)) return true;
board[i][j]='.';
}
}
return false;
}
}
}
return true;
}
bool isvalid(int row,int col,char val,vector<vector<char>>&board)
{
for(int i=0;i<9;i++){
if(board[row][i]==val){
return false;
}
}
for(int j=0;j<9;j++){
if(board[j][col]==val){
return false;
}
}
int startRow=(row/3)*3;
int startCol=(col/3)*3;
for(int i=startRow;i<startRow+3;i++){
for(int j=startCol;j<startCol+3;j++){
if (board[i][j] == val ) {
return false;
}
}
}
return true;
}
public:
void solveSudoku(vector<vector<char>>& board) {
backtracking(board);
}
};
740
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
