回溯: 核心是递归,沿一条路径走到底(得到结果)后,再回溯,继续得到其他的结果
组合问题:N个数⾥⾯按⼀定规则找出k个数的集合
排列问题:N个数按⼀定规则全排列,有⼏种排列⽅式切割问题:⼀个字符串按⼀定规则有⼏种切割⽅式
⼦集问题:⼀个N个数的集合⾥有多少符合条件的⼦集棋盘问题:
N皇后,解数独等等
模板:
void backtracking(参数)
{
if(符合结束条件(得到一种结果))
{
存放此此结果;
return;
}
for(i遍历可选择范围)
{
处理结点i
backtracking(...);//递归处理子问题
回溯,撤销最后的一次处理结果
}
}
组合
组合问题核心:解决无限的for循环嵌套问题,宽度为每次遍历数据可选的范围(注意每次可选范围的变化),深度为选择的数目,
for循环横向遍历,递归纵向遍历,回溯修改结果集(为获取新结果做准备)
剪枝:当剩下元素不足以构成结果集合(元素个数不够、元素和太小太大等)
横纵方向遍历就是一个多叉树,组合和分割问题都是取叶节点
集合中无重复元素【每个元素选一个:下次从i+1开始,每个元素随便选,下次从i开始】
有重复元素【每个元素选一个且无重复组合:i+1开始且去重】
例子求组合问题 [1,n]取k个数的可能
class Solution {
public:
vector<vector<int> > res;//储存所有结果
vector<int>buffer;//储存每次的结果
void backtracking(int n,int k,int begin)
{
if(!k)
{
res.push_back(buffer);
return ;
}
for(int i=begin;i<=n;i++)
{
buffer.push_back(i);
backtracking(n,k-1,i+1);//相当于选了i,再从[i+1,n]中挑选k-1个
//此处如果不用递归,就要k-1个循环[for(int j=i+1;j<=n;j++)
]
//因此递归就是解决过多的循环嵌套问题
buffer.pop_back(); // 回溯,撤销处理的节点
}
}
vector<vector<int>> combine(int n, int k)
{
backtracking(n,k,1);
return res;
}
};
k例子 k=3时的嵌套循环
/*
vector<vector<int>> combine(int n, int k)
{
for(int i=1;i<=n;i++)
{
buffer.push_back(i);
for(int j=i+1;j<=n;j++)
{
buffer.push_back(j);
for(int c=j+1;c<=n;c++)
{
buffer.push_back(c);
res.push_back(buffer);
buffer.pop_back();
}
buffer.pop_back();
}
buffer.pop_back();
}
return res;
}
*/
//此题自己确认每次遍历的序列
class Solution {
public:
vector<string>key,res;
string path;
Solution ()
{//储存每个案件对应的字母序列
key.push_back("abc");
key.push_back("def");
key.push_back("ghi");
key.push_back("jkl");
key.push_back("mno");
key.push_back("pqrs");
key.push_back("tuv");
key.push_back("wxyz");
}
void backtracking(string digits,int index,int size)
{//index标志正在遍历的字母序列 size标准此条路径还需要加入几个字符
if(!size)
{
res.push_back(path);
return ;
}
string now=key[digits[index]-'2'];//确定此次遍历的序列
for(int i=0;i<now.size();i++)
{
path.push_back(now[i]);
backtracking(digits,index+1,size-1);//从后面剩下的序列中取size-1个字符
path.pop_back();
}
}
vector<string> letterCombinations(string digits)
{
if(digits.size()==0)return res;
backtracking(digits,0,digits.size());
return res;
}
};
//此题每个数可以重复取,可取数中无重复
class Solution {
public:
vector<vector<int>>res;
vector<int>path;
int sum;
void backtracking(vector<int>& candidates,int target,int begin)
{
if(sum>target)return ;//剪枝
if(target==sum)
{
res.push_back(path);
return ;
}
for(int i=begin;i<candidates.size();i++)
{//虽然这里每个数个数无限取,但避免重复(例子23 32)每次递归从i开始不能往前
path.push_back(candidates[i]);
sum+=candidates[i];
backtracking(candidates,target,i);
path.pop_back();
sum-=candidates[i];
}
}
vector<vector<int>> combinationSum(vector<int>& candidates, int target)
{
backtracking(candidates,target,0);
return res;
}
};
class Solution {
public:去重
//此题每个数只能取一次,但可取数中有重复,在单个组合中数可以有重复,但不能有重复组合
//1 1 2 3 中1取自不同的1造成组合重复 1 2 ,1 2
//去重方式是每遍历一个序列时(同一树层)不能出现重复,同一路径可以重复
vector<vector<int>>res;
vector<int>path;
int sum;
void backtracking(vector<int>& candidates,int target,int begin,vector<bool>&used)
{
if(sum>target)return ;//剪枝
if(target==sum)
{
res.push_back(path);
return ;
}
//used.assign(candidates.size(),false);
for(int i=begin;i<candidates.size();i++)
{//虽然这里每个数个数无限取,但避免重复(例子23 32)每次递归从i开始不能往前
if(i>0&&candidates[i]==candidates[i-1]&&!used[i-1])
{//如果i==i-1表示这个值已经出现过这个值不在同一树层继续遍历,加上!used[i-1]是为不把同一路径下的相同值冲掉,同一路径继续遍历
continue;
}
path.push_back(candidates[i]);
sum+=candidates[i];
used[i]=true;
backtracking(candidates,target,i+1,used);
used[i] = false;
path.pop_back();
sum-=candidates[i];
}
}
vector<vector<int>> combinationSum2(vector<int>& candidates, int target)
{
//因此需要先进行排序
sort(candidates.begin(),candidates.end());
vector<bool>used(candidates.size(),false);
backtracking(candidates,target,0,used);
return res;
}
};
注意这里的去重方法,用used标志,同树层相同数字只能出现一次,不同数层可以重复
分割
//分割字符串相当于是把字符串中加分割符号,其实就是找加分割符号位置的组合(前提是判断是否构成分割条件才加入)
分割
class Solution {
public:
vector<vector<string>>res;
vector<string> path;
bool isPalindrome(string str)
{
for(int i=0,j=str.size()-1;i<j;i++,j--)
{
if(str[i]!=str[j])return false;
}
return true;
}
void backtracking(string s,int begin)
{
if(begin>=s.size())
{
res.push_back(path);
return ;
}
for(int i=begin;i<s.size();i++)
{
string str = s.substr(begin, i -begin +1);
if(isPalindrome(str))
{
path.push_back(str);
}
else continue;//前边分割不构成回文,往后再遍历可能会有
backtracking(s,i+1);
path.pop_back();
}
}
vector<vector<string>> partition(string s)
{
backtracking(s,0);
return res;
}
};
//本题只要求切成四段,且每段必须满足要求,所以不能任意分割
class Solution {
public:
vector<string>res;
bool isok(string s,int begin,int end)//判断此段字符串是否0-255
{
if(begin>end)return false;
if(s[begin]=='0'&&begin!=end)return false ;//字符为0开头但不只一个0
int sum=0;
for(int i=begin;i<=end;i++)
{
sum*=10;
sum+=s[i]-'0';
if(sum>255)return false;
}
return true;
}
//此算法采用在s中加逗号的方式
void backtracking(string s,int begin,int num_point)
{
if(num_point==3)
{
if(isok(s,begin,s.size()-1))//判断第4段是否合法
{
res.push_back(s);
}
return ;
}
for(int i=begin;i<s.size();i++)
{
if(isok(s,begin,i))
{//此段合法则插入逗号
// i
// 255,255
s.insert(s.begin()+i+1,'.');
//i+1是逗号,所以要越过逗号
backtracking(s,i+2,num_point+1); //point为已经插入的逗号数
s.erase(s.begin()+i+1);//回溯,删除此逗号
}
else break;//不合法了,往后插入也一定不合法,如2555,52532逗号在这不合适,后边更不合适(个数都大于4了)
}
}
vector<string> restoreIpAddresses(string s)
{
backtracking(s,0,0);
return res;
}
};
子集
子集问题是树中的所有结点都要进入
class Solution {
public:
vector<vector<int>>res;
vector<int>path;
void backtracking(vector<int>& nums,int begin)
{
res.push_back(path);//出现的所有组合都要进
if(begin>=nums.size())
{
return ;
}
for(int i=begin;i<nums.size();i++)
{
path.push_back(nums[i]);
backtracking(nums,i+1);//不能重复取所以从i+1开始
path.pop_back();
}
}
vector<vector<int>> subsets(vector<int>& nums)
{
backtracking(nums,0);
return res;
}
};
class Solution {
public:
//本题要去重
vector<vector<int>>res;
vector<int>path;
void backtracking(vector<int>& nums,int begin,vector<bool>used)
{
res.push_back(path);//出现的所有组合都要进
if(begin>=nums.size())
{
return ;
}
for(int i=begin;i<nums.size();i++)
{
if(i>0&&nums[i]==nums[i-1]&&used[i-1]==false)
continue;
used[i]=true;
path.push_back(nums[i]);
backtracking(nums,i+1,used);//不能重复取所以从i+1开始
path.pop_back();
used[i]=false;
}
}
vector<vector<int>> subsetsWithDup(vector<int>& nums)
{
sort(nums.begin(),nums.end());
vector<bool>used(nums.size(),false);
backtracking(nums,0,used);
return res;
}
};
class Solution {
public:
vector<vector<int>>res;
vector<int>path;
void backtracking(vector<int>& nums,int begin)
{
if(path.size()>=2)
res.push_back(path);//出现的所有组合都要进
if(begin>=nums.size())
{
return ;
}
unordered_set<int> uset;
//用1个set来去重,只管同一层中此元素是否出现,出现过则跳过该元素
for(int i=begin;i<nums.size();i++)
{
if(uset.find(nums[i])!=uset.end())continue;
//uset,find找不到返回end迭代器,去重作用
// continue;
if(path.size()>=1&&nums[i]<path[path.size()-1])continue; //判断递增作用
uset.insert(nums[i]);
path.push_back(nums[i]);
backtracking(nums,i+1);//不能重复取所以从i+1开始
path.pop_back();
}
}
vector<vector<int>> findSubsequences(vector<int>& nums)
{
backtracking(nums,0);
return res;
}
};
排列
顺序现在起作用了01 和10不一样,所以i每次从0开始遍历整个序列,但是同一个数不能重复取,因此要去重
//排列问题有顺序了所以元素位置有影响,每次从0开始选
//只是注意每个元素不能重复选,即路径上不能有重复元素,所以用个used去重
class Solution {
public:
vector<vector<int>>res;
vector<int>path;
void backtracking(vector<int>& nums,vector<bool>used)
{
if(path.size()==nums.size())
{
res.push_back(path);
return ;
}
for(int i=0;i<nums.size();i++)//有顺序了所以元素位置有影响,每次从0开始选
//只是注意每个元素不能重复选,即路径上不能有重复元素,所以用个used去重
{
if(used[i])continue;
used[i]=true;
path.push_back(nums[i]);
backtracking(nums,used);//不能重复取所以从i+1开始
path.pop_back();
used[i]=false;
}
}
vector<vector<int>> permute(vector<int>& nums)
{
vector<bool>used(nums.size(),false);
backtracking(nums,used);
return res;
}
};
//序列中有重复元素
class Solution {
public:
vector<vector<int>>res;
vector<int>path;
void backtracking(vector<int>& nums,vector<bool>used)
{
if(path.size()==nums.size())
{
res.push_back(path);
return ;
}
int hash[21]={0};
for(int i=0;i<nums.size();i++)//有顺序了所以元素位置有影响,每次从0开始选
//只是注意每个元素不能重复选,即路径上不能有重复元素,所以用个used去重路径的
//因为序列中有重复元素,因此每一树层也不能重复取,所以用hash去重树层的
{
if(hash[nums[i]+10])continue;
if(used[i])continue;
used[i]=true;
hash[nums[i]+10]=1;
path.push_back(nums[i]);
backtracking(nums,used);//不能重复取所以从i+1开始
path.pop_back();
used[i]=false;
}
}
vector<vector<int>> permuteUnique(vector<int>& nums)
{
vector<bool>used(nums.size(),false);
backtracking(nums,used);
return res;
}
};
棋盘问题
从第一行开始每次在第一行以j列加入一个王后,然后再在后边的行中递归加入
树层遍历所有行,树路径遍历列
class Solution {
public:
vector<vector<string>> res;
bool isvalid(int row,int col,vector<string>& keyborad,int n)
{//判断在row col处加上皇后是否合法
//判断直上
for(int i=row-1;i>=0;i--)
{
if(keyborad[i][col]=='Q')return false;
}
//判断左上角
for(int i=row-1,j=col-1;i>=0&&j>=0;i--,j--)
{
if(keyborad[i][j]=='Q')return false;
}
//判断右上角
for(int i=row-1,j=col+1;i>=0&&j<n;i--,j++)
{
if(keyborad[i][j]=='Q')return false;
}
//因为刚递归到第row行 所有row行下边不用判断 且因为每树层同时只有一个Q所有左右也不用判断
return true;
}
void backtracking(int row,vector<string>& keyborad,int n)
{//keyborad存储此时的棋盘状况
if(row==n)
{
res.push_back(keyborad);
return ;
}
for(int col=0;col<n;col++)//遍历此行的所有列
{
if(!isvalid(row,col,keyborad,n))continue;
keyborad[row][col]='Q';
backtracking(row+1,keyborad,n);//继续在下一行插入皇后
keyborad[row][col]='.';
}
}
vector<vector<string>> solveNQueens(int n)
{
vector<string> keyborad(n, string(n, '.'));
backtracking(0,keyborad,n);
return res;
}
};
class Solution {
public:
/*解数独本题与N皇后不同的是,同样是一个N*N的棋盘,N皇后每一行列只有放一个皇后
而此题每个位置是可以放9个数字中一个,因此本题是一个二维递归问题
也就是两个循环遍历棋盘每行每列,每个位置可以放九个数字递归放置9个数字
本题没有终止条件,是因为当棋盘全部覆盖是自动就是,也只有此种情况下问题解决,
而且题目默认只有一个答案
只判断是否填满,就结束
*/
bool backtracking(vector<vector<char>>& board)
{
for(int i=0;i<9;i++)//遍历行
{
for(int j=0;j<9;j++)//遍历列
{
if(board[i][j]!='.')continue;//本位置已经填上,不需要递归
for(char k='1';k<='9';k++)
{
//找到未放的位置ij放上一个数字,递归放剩下的格子,如果ij处放上k,剩下全部放上满足直接返回
if(!isValid(i,j,k,board))continue;
board[i][j]=k;
if(backtracking(board))return true;
board[i][j]='.';//回溯
}
return false;
//此位置放什么都不行,也就是前面放的出错了,再回溯到前面重新放其他的
}
}
return true;//没返回false则证明上面有戏
}
bool isValid(int i,int j,char k,vector<vector<char>>& board)
{//判断在ij处放上k是否合理
for(int col=0;col<9;col++)
{//判断此行
if(board[i][col]==k)return false;
}
for(int row=0;row<9;row++)
{
if(board[row][j]==k)return false;
}
//此为每块的左上角元素下标
int start_row=(i/3)*3;
int start_col=(j/3)*3;
for(int row=start_row;row<start_row+3;row++)
{//判断所属的3X3格内
for(int col=start_col;col<start_col+3;col++)
{
if(board[row][col]==k)return false;
}
}
return true;
}
void solveSudoku(vector<vector<char>>& board)
{
backtracking(board);
}
};