剑指offer--第14天

剑指 Offer 12. 矩阵中的路径
这题是判断是否能找到连接起来的指定字符串，预处理先将与字符串开头一样的字符的位置记录起来，然后从这几个位置搜索即可，当答案已经存在时，就不用再继续搜索，否则会超时

class Solution {
public:
    bool vis[201][201];
    bool ans=0;
    int cal;
    int raw;
    void dfs(int x,int y,string s,int cnt,vector<vector<char>>& board)
    {
        if(ans) return ;
        if(cnt==s.size()){ans=true;return ;}
        if(x+1<cal&&!vis[x+1][y]){
            if(s[cnt]==board[x+1][y]){
                vis[x+1][y]=true;
                dfs(x+1,y,s,cnt+1,board);
                vis[x+1][y]=false;
            }
        }
        if(x-1>=0&&!vis[x-1][y]){
            if(s[cnt]==board[x-1][y]){
                vis[x-1][y]=true;
                dfs(x-1,y,s,cnt+1,board);
                vis[x-1][y]=false;
            }
        }
        if(y+1<raw&&!vis[x][y+1]){
            if(s[cnt]==board[x][y+1]){
                vis[x][y+1]=true;
                dfs(x,y+1,s,cnt+1,board);
                vis[x][y+1]=false;
            }
        }
        if(y-1>=0&&!vis[x][y-1]){
            if(s[cnt]==board[x][y-1]){
                vis[x][y-1]=true;
                dfs(x,y-1,s,cnt+1,board);
                vis[x][y-1]=false;
            }
        }
    }
    bool exist(vector<vector<char>>& board, string word) {
        vector<int>v;
        cal=board.size();
        raw=board[0].size();
        if(cal*raw<word.size()) return ans;
        for(int i=0;i<cal;i++){
            for(int j=0;j<raw;j++){
                vis[i][j]=false;
                if(board[i][j]==word[0]){
                    v.push_back(i*raw+j);
                }
            }
        }
        for(int i=0;i<v.size();i++)
        {
            int x=v[i]/raw;
            int y=v[i]%raw;
            vis[x][y]=true;
            if(word.size()==1){
                ans=true;
                break;
            }
            dfs(x,y,word,1,board);
            vis[x][y]=false;
            if(ans) break;
        }
        return ans;
    }
};

剑指 Offer 13. 机器人的运动范围
这题需要对每一个数进行一遍处理，我们将每一个数的每一位取出来求和，然后赋值到该位置，再进行广搜，广搜的同时需要加上标记数组

class Solution {
public:
    bool vis[101][101];
    struct node{
        int x,y,z;
    };
    int check(int x,int y){
        int sum=0;
        while(x){
            sum+=x%10;
            x/=10;
        }
        while(y){
            sum+=y%10;
            y/=10;
        }
        return sum;
    }
    int movingCount(int m, int n, int k) {
        int v[m+1][n+1];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                v[i][j]=check(i,j);
                vis[i][j]=false;
            }
        }
        queue<node>q;
        int ans=0;
        q.push({0,0,1});
        vis[0][0]=true;
        while(!q.empty()){
            node t;
            t=q.front();
            q.pop();
            int xi=t.x;
            int yi=t.y;
            ans++;
            if(xi+1<m&&!vis[xi+1][yi]&&v[xi+1][yi]<=k){
                q.push({xi+1,yi,t.z+1});
                vis[xi+1][yi]=true;
            }
            if(yi+1<n&&!vis[xi][yi+1]&&v[xi][yi+1]<=k){
                q.push({xi,yi+1,t.z+1});
                vis[xi][yi+1]=true;
            }
        }
        return ans;
    }
};