回溯算法刷题总结笔记(持续更新中)

回溯： 核心是递归，沿一条路径走到底（得到结果）后，再回溯，继续得到其他的结果

组合问题：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);
    }
};