【递归、搜索与回溯】综合练习

cefler

已于 2024-01-15 11:27:13 修改

阅读量464

点赞数 9

分类专栏：递归、搜索与回溯文章标签：算法递归、回溯、深搜

于 2024-01-01 18:29:33 首次发布

本文链接：https://blog.csdn.net/cefler/article/details/135323381

版权

递归、搜索与回溯专栏收录该内容

6 篇文章 0 订阅

订阅专栏

在这里插入图片描述

欢迎来到Cefler的博客😁
🕌博客主页：那个传说中的man的主页
🏠个人专栏：题目解析
🌎推荐文章：题目大解析（3）

在这里插入图片描述

👉🏻找出所有子集的异或总和再求和
👉🏻全排列 II
👉🏻电话号码的字母组合
👉🏻括号生成
👉🏻组合
👉🏻目标和
👉🏻组合总和
👉🏻 字母大小写全排列
👉🏻优美排列
👉🏻N皇后👑
👉🏻有质的数独
👉🏻解数独
👉🏻单词搜索（floodfill算法思想）
👉🏻黄金矿工（floodfill算法思想）
👉🏻不同路径 III（floodfill算法思想）

👉🏻找出所有子集的异或总和再求和

原题链接：找出所有子集的异或总和再求和

mycode:

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void dfs(vector<int>& nums,int n)
    {
        for(int i = n ;i<nums.size();i++)
        {
            path.push_back(nums[i]);
            dfs(nums,i+1);

            path.pop_back();
        }

        res.push_back(path);
    }
    int subsetXORSum(vector<int>& nums) {
        dfs(nums,0);
        int Sum  = 0;
        for(int i = 0;i<res.size();i++)
        {
            int sum = 0;
            for(auto e:res[i])
            {
                sum^=e;
            }
            Sum+=sum;
        }
        return Sum;
    }
};

优化代码（纯递归）：

class Solution {
public:
    int Sum = 0,sum = 0;
    void dfs(vector<int>& nums,int n)
    {
        for(int i = n ;i<nums.size();i++)
        {
            sum^=nums[i];
            dfs(nums,i+1);
            sum^=nums[i];//再异或一遍可以消掉
        }
       Sum+=sum;
    }
    int subsetXORSum(vector<int>& nums) {
        dfs(nums,0);
        return Sum;
    }
};

👉🏻全排列 II

原题链接：全排列 II

mycode:

class Solution {
public:
    vector<vector<int>> ret;
    vector<int> path;
   
    bool check[8];//检查该位置是否被用过了，true说明被用过了 
    void dfs(vector<int>& nums)
    {
        if(nums.size()==path.size())//说明此时已经组成一个序列了
        {
            ret.push_back(path);
            return;
        }
        for(int i = 0;i<nums.size();i++)
        {
            if(check[i]==false && (i==0||nums[i]!=nums[i-1]||check[i-1]==true))//此时还没被用过&&第一层||前后值不重复相等||不在同一层
            {
                path.push_back(nums[i]);
                check[i] = true;
                dfs(nums);
                //回溯清空现场，将dfs下层插入的元素pop掉
                path.pop_back();
                check[i] = false;
                

            }
        }
    }

    vector<vector<int>> permuteUnique(vector<int>& nums) {
        //前提先排序
        sort(nums.begin(),nums.end());
        dfs(nums);
        return ret;
    }
};

在这里插入图片描述

👉🏻电话号码的字母组合

原题链接：电话号码的字母组合

mycode:

class Solution {
public:
   const char* numsArr[10] = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
   void Combine(const string& digits,string combinestr,int i ,vector<string>& ret)
   {
       if(i == digits.size())//当数字中的字母全部都进行完组合后
       {
           ret.push_back(combinestr);
           return;
       }
      int num = digits[i] - '0';
      string str = numsArr[num];
       for(auto ch:str)
       {
           Combine(digits,combinestr+ch,i+1,ret);
       }
   }
    vector<string> letterCombinations(const string& digits) {
           vector<string> v;//存储全部组合的字符串
           if(digits=="")
           return v;
           string str;//这个是专门用来组合的字符串
           int i =0;
           Combine(digits,str,i,v);
           return v;
 
    }
};

加入恢复现场代码优化：

class Solution {
public:
   const char* numsArr[10] = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
   vector<string> ret;
   string combinestr;
   void Combine(const string& digits,int i )
   {
       if(i == digits.size())//当数字中的字母全部都进行完组合后
       {
           ret.push_back(combinestr);
           return;
       }
      int num = digits[i] - '0';
      string str = numsArr[num];
       for(auto ch:str)
       {
           combinestr+=ch;
           Combine(digits,i+1);
           //恢复现场
           combinestr.pop_back();
       }
   }
    vector<string> letterCombinations(const string& digits) {
           if(digits=="")
           return ret;
           Combine(digits,0);
           return ret;
 
    }
};

👉🏻括号生成

原题链接：括号生成

mycode:

class Solution {
public:
    vector<string> ret;
    string path;
    int left = 0,right = 0;
    void dfs(int n)
    {
        if(left+right==2*n) 
        {
            ret.push_back(path);
            return;
        }
        if(left<n)
      {
            path.push_back('(');
            left++;
            dfs(n);
            path.pop_back();
            left--;
      }
      if(right<left)
      {
          path.push_back(')');
          right++;
          dfs(n);
            path.pop_back();
            right--;
      }    
    }
    vector<string> generateParenthesis(int n) {
        dfs(n);
        return ret;
    }
};

在这里插入图片描述

👉🏻组合

原题链接：组合

mycode:

class Solution {
public:
    vector<vector<int>> ret;
    vector<int> path;
    int _k;
    void dfs(int n,int pos)
    {
         if(path.size()==_k)
            {
                ret.push_back(path);
                return;
            }
        for(int i = pos;i<=n;i++)
        {
            path.push_back(i);
            dfs(n,i+1);//i+1是换层，n+1是在同一层里换元素
            //恢复现场
            path.pop_back();
        }
    }
    vector<vector<int>> combine(int n, int k) {
        _k = k;
        dfs(n,1);
        return ret;
    }
};

在这里插入图片描述

如这种左大右小的树，一般就是i+1进行深度优先遍历，如果是完全二叉树，则是n+1这种广度遍历

👉🏻目标和

原题链接：目标和

mycode1:

class Solution {
public:
    int count = 0;
    int _target;
    void dfs(vector<int>& nums,int i,int sum)
    {
        if(i==nums.size()) 
        {
            if(sum == _target) count++;
            return;
        }
        dfs(nums,i+1,sum+nums[i]);//加
        dfs(nums,i+1,sum-nums[i]);//减
    }
    int findTargetSumWays(vector<int>& nums, int target) {
        _target = target;
        dfs(nums,0,0);
        return count;
    }
};

mycode2:

class Solution {
public:
    int count = 0;
    int _target;
    int sum = 0;
    void dfs(vector<int>& nums,int i)
    {
        if(i==nums.size()) 
        {
            if(sum == _target) count++;
            return;
        }
        sum+=nums[i];
        dfs(nums,i+1);
        //恢复现场
        sum-=nums[i];

        sum-=nums[i];
        dfs(nums,i+1);
        //恢复现场
        sum+=nums[i];

    }
    int findTargetSumWays(vector<int>& nums, int target) {
        _target = target;
        dfs(nums,0);
        return count;
    }
};

👉🏻组合总和

原题链接：组合总和
采用暴力搜索的方式

在这里插入图片描述
mycode:

class Solution {
public:
    vector<vector<int>> ret;
    vector<int> path;
    int aim;
    void dfs(vector<int>& candidates,int pos,int sum)
    {
        if(sum==aim)
        {
            ret.push_back(path);
            return;
        }
        else if(sum>aim||pos==candidates.size()) return;
        for(int i = pos;i<candidates.size();i++)
        {
            path.push_back(candidates[i]);
            dfs(candidates,i,sum+candidates[i]);
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        aim = target;
        dfs(candidates,0,0);
        return ret;
    }
};

解析剪枝

for(int i = pos;i<candidates.size();i++)//对于同一层，前面已经用过的数字在下一分支不会再用了，所以用一个Pos记录下一分支的起始点
        {
            path.push_back(candidates[i]);
            dfs(candidates,i,sum+candidates[i]);//这里传i是因为同一个数字可以无限制重复被选取，如果不能被重复选取，则i+1
            path.pop_back();
        }

这个决策树明显是左大右小的树，所以dfs这里传的是i而不是pos。

解法二：
在这里插入图片描述
mycode:

class Solution {
public:
    vector<vector<int>> ret;
    vector<int> path;
    int aim;
    void dfs(vector<int>& candidates,int pos,int sum)
    {
       if(sum==aim)
        {
            ret.push_back(path);
            return;
        }
        else if(sum>aim||pos==candidates.size()) return;
        //枚举个数
        for(int k = 0;k*candidates[pos]<=aim;k++){
            if(k) path.push_back(candidates[pos]);
            dfs(candidates,pos+1,sum+k*candidates[pos]);
        }
        //恢复现场
        for(int k = 1;k*candidates[pos]<=aim;k++){
            path.pop_back();
        }

    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        aim = target;
       dfs(candidates,0,0);
       return ret;
    }

恢复现场解释：

 for(int k = 1;k*candidates[pos]<=aim;k++){//k = 0时没有插入，所以从k = 1开始pop
            path.pop_back();
        }

为什么不是从dfs(candidates,pos+1,sum+k*candidates[pos]);后开始恢复现场？
因为这个树的遍历有点深度和广度结合的遍历，当回溯到某一节点时，其下的所有叶子节点都已经插入，所以如果要恢复现场，就要一次性把所有叶子节点pop掉

👉🏻 字母大小写全排列

原题链接：字母大小写全排列

mycode:

class Solution {
public:
    vector<string> ret;
    string path;

    void dfs(string s,int pos)
    {
        if(pos==s.size())
        {
            ret.push_back(path);
            return;
        }
        if(isalpha(s[pos]))
        {
            if(islower(s[pos]))
            {
                path+=s[pos];
                dfs(s,pos+1);
                //恢复现场
                path.pop_back();
                path+=toupper(s[pos]);
                dfs(s,pos+1);
                path.pop_back();

            }
            else if(isupper(s[pos]))
            {
                path+=s[pos];
                dfs(s,pos+1);
                //恢复现场
                path.pop_back();
                path+=tolower(s[pos]);
                dfs(s,pos+1);
                path.pop_back();

            }
        }
        else
            {
                path+=s[pos];
                dfs(s,pos+1);
                path.pop_back();
            }
    }
    vector<string> letterCasePermutation(string s) {
        dfs(s,0);
        return ret;
    }
};

👉🏻优美排列

原题链接：优美排列

mycode（错误代码）:

class Solution {
public:
    int count = 0;
    vector<int> path;
    bool check[16];
    void dfs(vector<int>& nums)
    {
        if(path.size()==nums.size()-1)
        {
            count++;
            return;
        }
        for(int i = 1;i<nums.size();i++)
        {
           if (check[i] == false)
        {
            int index = path.size();
            if (nums[i]% (index + 1) != 0 && (index + 1) % nums[i] != 0)
            {
                return;
            }
            path.push_back(nums[i]);
            check[i] = true;
            
            
            dfs(nums);
            path.pop_back();
            check[i] = false;
        }
        }
    }
    int countArrangement(int n) {
        vector<int> nums(n + 1);
     for (int i = 1; i <= n; i++) nums[i] = i;
     dfs(nums);
     return count;
    }
};

修正code:

class Solution {
public:
    int count = 0;
    vector<int> path;
    bool check[16];
    void dfs(vector<int>& nums)
    {
        if(path.size()==nums.size()-1)
        {
            count++;
            return;
        }
        for(int i = 1;i<nums.size();i++)
        {
     
            int index = path.size();
        if (check[i] == false&&(nums[i] % (index + 1) == 0 || (index + 1) % nums[i] == 0))
        {
         
            path.push_back(nums[i]);
            check[i] = true;
            
            
            dfs(nums);
            path.pop_back();
            check[i] = false;
        }
        }
    }
    int countArrangement(int n) {
        vector<int> nums(n + 1);
     for (int i = 1; i <= n; i++) nums[i] = i;
     dfs(nums);
     return count;
    }
};

👉🏻N皇后👑

原题链接：N皇后👑
在这里插入图片描述

dig开始2n大小是因为,b<=n,而b+n<=2n,所以至少开2n

在这里插入图片描述

mycode:

class Solution {
public:
    vector<vector<string>> ret;
    vector<string> board;
    bool dig1[19],dig2[19],col[10];
    int N;
    void dfs(int row)
    {
        if(row==N)
        {
            ret.push_back(board);
            return;
        }
        for(int cl = 0;cl<N;cl++)
        {
            //检查是否能放皇后：1.col[cl] == false,该列上面没有皇后 &&2.dig1[cl-row+N]==false&&dig2[cl+row]==false两个斜线上都没有皇后
            int flag = 0;
            if(col[cl]==false&&(dig1[cl-row+N]==false&&dig2[cl+row]==false))
            {
                board[row][cl] = 'Q';
                col[cl]= true;
                dig1[cl-row+N]= true;
                dig2[cl+row]= true;
                flag = 1;
            }
            if(flag)
            {
                //改行已经添加皇后后，才递归到下一层，即递归到下一行;否则继续循环，遍历列
                dfs(row+1);
                //恢复现场
                board[row][cl] = '.';
                col[cl]= false;
                dig1[cl-row+N]= false;
                dig2[cl+row]= false;
            }
        }
    }
    vector<vector<string>> solveNQueens(int n) {
       vector<string> tmp(n, string(n, '.'));
         board = tmp;
        N = n;
        dfs(0);
        return ret;
    }
};

You did it,bro! 成功代码实现👑

👉🏻有质的数独

原题链接：有质的数独
在这里插入图片描述
mycode:

class Solution {
public:
    bool row[9][10];//检查每一行1-9是否出现过
    bool col[9][10];
    bool grid[3][3][10];
    bool isValidSudoku(vector<vector<char>>& board) {
        for(int i = 0;i<9;i++)
        {
            for(int j = 0;j<9;j++)
            {
                if(!isdigit(board[i][j]))
                    continue;
                int num = board[i][j]-'0';
                if(row[i][num]||col[j][num]||grid[i/3][j/3][num])//但凡一个触犯就是错
                    return false;

                row[i][num] = true;
                col[j][num] = true;
                grid[i/3][j/3][num] = true;
            }
        }
        return true;
    }
};

👉🏻解数独

原题链接：解数独

mycode:

class Solution {
public:
     bool row[9][10];//检查每一行1-9是否出现过
    bool col[9][10];
    bool grid[3][3][10];
    bool dfs(vector<vector<char>>& board)
    {
       for(int i = 0;i<9;i++)
        {
            for(int j = 0;j<9;j++)
            {
                if(board[i][j]=='.')
                {
                    for(int n = 1;n<=9;n++)
                    {
                        //检查是否合法
                        if(!row[i][n]&&!col[j][n]&&!grid[i/3][j/3][n])
                            {
                                board[i][j] = n+'0';
                                row[i][n] = col[j][n] = grid[i/3][j/3][n] = true;
                                if(dfs(board)) return true;
                                //恢复现场
                                board[i][j] = '.';
                                row[i][n] = col[j][n] = grid[i/3][j/3][n] = false;
                            }

                    }
                    //1-9都不行，返回false
                    return false;
                }
                
            }
        }
        return true;//都填完了
    }
    void solveSudoku(vector<vector<char>>& board) {
        //初始化
        for(int i = 0;i<9;i++)
        {
            for(int j = 0;j<9;j++)
            {
                if(board[i][j]!='.')
                {
                    int num = board[i][j]-'0';
                    row[i][num] = true;
                    col[j][num] = true;
                    grid[i/3][j/3][num] = true;
                }
            }
        }
        dfs(board);
    }
};

👉🏻单词搜索（floodfill算法思想）

原题链接：单词搜索
策略：深搜

mycode1（超出时间限制）:

class Solution {
public:
    int flag = 0;
    string _word;
    bool isValid(vector<vector<char>>& board,int i,int j)//检查坐标是否合法
    {
        if(i<0||i>=board.size()||j<0||j>=board[0].size()) return false;
        else return true;
    }
    void dfs(vector<vector<char>>& board,string path,int i,int j,vector<vector<bool>> check)
    {
        if(path.size()==_word.size()||isValid(board,i,j)==false||check[i][j]) return;//长度已经达标或者坐标违法,该坐标已经使用过了
        path+=board[i][j];
        check[i][j] = true;
        if(path ==_word)
        {
            flag = 1;
            return;
        }
        //上下左右
        dfs(board,path,i-1,j,check);
        
        dfs(board,path,i+1,j,check);
       
        dfs(board,path,i,j-1,check);

        dfs(board,path,i,j+1,check);

    }
    bool exist(vector<vector<char>>& board, string word) {
        _word = word;
        for(int i = 0;i<board.size();i++)
        {
            for(int j = 0;j<board[0].size();j++)
            {
                    string path;
                    vector<vector<bool>> check(board.size(),vector<bool>(board[0].size()));
                    if(board[i][j]== word[0])
                   {
                       dfs(board,path,i,j,check);
                        if(flag) return true; 
                   }
            }
        }
        return false;
    }
};

mycode2:

class Solution {
public:
    bool check[7][7];
    //创建向量表达式，表示上下左右四个位置
    int dx[4] = {0,0,-1,1};
    int dy[4] = {1,-1,0,0};
    bool isValid(vector<vector<char>>& board,int i,int j)//检查坐标是否合法
    {
        if(i<0||i>=board.size()||j<0||j>=board[0].size()) return false;
        else return true;
    }
    bool dfs(vector<vector<char>>& board,string& word,int i,int j,int pos)
    {
        if(pos == word.size()) return true;
        for(int k = 0;k<4;k++)
        {
            int x = i+dx[k], y = dy[k]+ j;
            if(isValid(board,x,y)&&!check[x][y]&&board[x][y]==word[pos])
            {
                check[x][y] = true;
                if(dfs(board,word,x,y,pos+1)) return true;
                //恢复现场
                check[x][y] = false;
            }
        }
        //如果上下左右四个位置都不行，则说明该位置当前选择错误，返回false
        return false;
    }
    bool exist(vector<vector<char>>& board, string word) {
        for(int i = 0;i<board.size();i++)
        {
            for(int j = 0;j<board[0].size();j++)
            {
                if(board[i][j]==word[0])
                {
                    check[i][j] = true;
                    if(dfs(board,word,i,j,1)) return true;
                    check[i][j] = false;
                }
            }
        }
        return false;
    }
};

在这里插入图片描述

👉🏻黄金矿工（floodfill算法思想）

原题链接：黄金矿工

mycode:

class Solution {
public:
    //创建向量表达式，表示上下左右四个位置
    int dx[4] = {0,0,-1,1};
    int dy[4] = {1,-1,0,0};
    bool check[16][16];
    int m,n;
    vector<int> v;
    void dfs(vector<vector<int>>& grid,int i,int j,int sum)
    {
      
        for(int k = 0;k<4;k++)
        {
            int x = i+dx[k], y = dy[k]+ j;
            if(x>=0&&x<m&&y>=0&&y<n&&grid[x][y]!=0&&!check[x][y])
            {
                check[x][y] = true;
                dfs(grid,x,y,sum+grid[x][y]);
                //恢复现场
                check[x][y] = false;
            }
            else if (x < 0 || x >= m || y < 0 || y >= n) v.push_back(sum);
        }
        //上下左右都走不了
        v.push_back(sum);
    }
    int getMaximumGold(vector<vector<int>>& grid) {
        m = grid.size(),n = grid[0].size();
        for(int i = 0;i<m;i++){
            for(int j = 0;j<n;j++){
                if(grid[i][j]!=0)
                {
                    check[i][j] = true;
                    dfs(grid,i,j,grid[i][j]);
                    //恢复现场
                    check[i][j] = false;
                }
            }
        }
        int max = 0;
        for(auto e :v) if(e>max) max = e;
        return max;
    }
};

👉🏻不同路径 III（floodfill算法思想）

原题链接：不同路径 III

mycode:

class Solution {
public:
    int dx[4] = {0,0,-1,1};
    int dy[4] = {1,-1,0,0};
    bool check[21][21];//check就是用来对付你这种要求不能重复通过同一个方格的家伙
    int steps = 0;//要走的总步数
    int m,n;
    int count = 0;//记录可行的路径数
    void dfs(vector<vector<int>>& grid,int i,int j,int step)
    {
        if(grid[i][j]==2)
        {
            if((step-1) == steps) count++;
            return;
        }
        for(int k = 0;k<4;k++)
        {
            int x = i+dx[k], y = dy[k]+ j;
            if(x>=0&&x<m&&y>=0&&y<n&&grid[x][y]!=-1&&!check[x][y])
            {
                check[x][y] = true;
                dfs(grid,x,y,step+1);
                //恢复现场
                check[x][y] = false;
            }
            
        }
    }
    int uniquePathsIII(vector<vector<int>>& grid) {
        m = grid.size(),n = grid[0].size();
        for(int i = 0;i<m;i++)
        {
            for(int j = 0;j<n;j++)
            {
                if(grid[i][j]==0) steps++;
            }
        }
         for(int i = 0;i<m;i++)
        {
            for(int j = 0;j<n;j++)
            {
                if(grid[i][j]==1)//开始起步
                {
                    check[i][j] = true;
                    dfs(grid,i,j,0);
                    break;
                }
            }
        }
        return count;
    }
};