回溯法（09）

最新推荐文章于 2021-03-18 00:51:50 发布

Xu_lib

最新推荐文章于 2021-03-18 00:51:50 发布

阅读量178

点赞数

分类专栏：剑指Offer

本文链接：https://blog.csdn.net/Jeffxu_lib/article/details/100742723

版权

剑指Offer 专栏收录该内容

42 篇文章 1 订阅

订阅专栏

题一：矩阵的路径

1、分析：通常是用递归来实现其代码，尤其注意边界条件。

2、代码为：

class Solution {
public:
    bool hasPath(char* matrix, int rows, int cols, char* str)
    {
        if(matrix==nullptr||rows<1||cols<1||str==nullptr)
            return false;
        bool* visit=new bool[rows*cols];
        memset(visit,0,rows*cols);
        int pathLength=0;
        for(int row=0;row<rows;++row)
        {
            for(int col=0;col<cols;++col)
            {
                if(hasPathCore(matrix,rows,row,cols,col,str,pathLength,visit))
                {
                    return true;
                }
            }
        }
        delete[] visit;
        return false;
    }
    
    bool hasPathCore(const char* matrix,int rows,int row,int cols,int col,const char* str,
                    int& pathLength, bool* visit)
    {
        if(str[pathLength]=='\0')
            return true;
        bool hasThePath=false;
        if(row>=0 && row<rows && col>=0 && col<cols && 
          matrix[row*cols+col]==str[pathLength] && 
          !visit[row*cols+col])
        {
            ++pathLength;
            visit[row*cols+col]=true;
            
            hasThePath=hasPathCore(matrix,rows,row-1,cols,col,str,pathLength,visit)
                || hasPathCore(matrix,rows,row,cols,col+1,str,pathLength,visit)
                || hasPathCore(matrix,rows,row+1,cols,col,str,pathLength,visit)
                || hasPathCore(matrix,rows,row,cols,col-1,str,pathLength,visit);
            
            if(!hasThePath)
            {
                --pathLength;
                visit[row*cols+col]=false;
            }
        }
        return hasThePath;
    }

};

题二：机器人的运动范围

1、分析：

将其看成二维数组来进行对待，然后用回溯法来求解

2、代码如下：

class Solution {
public:
    int movingCount(int threshold, int rows, int cols)
    {
        if(rows<1||cols<1)
            return 0;
        bool* visit=new bool[rows*cols];
        memset(visit,0,rows*cols);
        int countGrid=canGetGrids(threshold,rows,cols,0,0,visit);
        delete[] visit;
        return countGrid;
    }
    
    int canGetGrids(int threshold,int rows,int cols,int row,int col,bool* visit)
    {
        int num=0;
        if(meetCondition(threshold,rows,cols,row,col,visit))
        {
            visit[row*cols+col]=true;
            num=1+canGetGrids(threshold,rows,cols,row-1,col,visit)
                +canGetGrids(threshold,rows,cols,row+1,col,visit)
                +canGetGrids(threshold,rows,cols,row,col-1,visit)
                +canGetGrids(threshold,rows,cols,row,col+1,visit);
        }
        return num;
    }
    
    bool meetCondition(int threshold,int rows,int cols,int row,int col,bool* visit)
    {
        if(row>=0 && row<rows && col>=0 && col<cols && getDigitSum(row,col)<=threshold
           && !visit[row*cols+col])
            return true;
        return false;
    }
    
    int getDigitSum(int row,int col)
    {
        int digitSum=0;
        digitSum+=row/10;
        digitSum+=row%10;
        digitSum+=col/10;
        digitSum+=col%10;
        return digitSum;
    }
};