算法刷题计划（二十）填充每个节点的下一个右侧节点指针 II、另一棵树的子树、二进制矩阵中的最短路径、被围绕的区域、所有可能的路径

一、填充每个节点的下一个右侧节点指针 II

• 题目:
  
  

• 题解：

• 方法一（广度优先搜索bfs）:

Node*connect(Node*root){
        if(!root)   return root;
        queue<Node*>que;
        que.push(root);
        while(!que.empty()){
            Node*last = NULL;
            int n=que.size();
            for(int i=1;i<=n;i++){
                Node*f=que.front();
                que.pop();
                if(f->left){
                    que.push(f->left);
                }
                if(f->right){
                    que.push(f->right);
                }
                if(i!=1){
                    last->next=f;
                }
                last=f;
            }
        }
        return root;
    }

二、另一棵树的子树

• 题目：
  
  
• 题解：
• 方法一（深度优先搜索dfs）:

class Solution {
public:
    bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        return dfs(root,subRoot);
    }  
    bool dfs(TreeNode*o,TreeNode*t){
        if(!o){
            return false;
        }
        return check(o,t)||dfs(o->left,t)||dfs(o->right,t);
    }
    bool check(TreeNode*o,TreeNode*t){
        if(!o&&!t){
            return true;
        }
        if((!o&&t)||(o&&!t)||(o->val!=t->val)){
            return false;
        }
        return check(o->left,t->left)&&check(o->right,t->right);
    }
};

三、二进制矩阵中的最短路径

• 题目：

• 题解：

class Solution {
public:
    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
        int n =grid.size();
        if(grid[0][0]==1||grid[n-1][grid[0].size()-1]==1)   return -1;
        if(n==1)    return 1;
        queue<pair<int,int>>que;
        vector<vector<int>>dir{{-1,0},{1,0},{0,-1},{0,1},{-1,-1},{1,1},{1,-1},{-1,1}};
        que.push({0,0});
        int step=2;
        while(!que.empty()){
            int len = que.size();
            for(int i=0;i<len;i++){
                auto p =que.front();
                que.pop();
                for(int j=0;j<8;++j){
                    int dx = p.first +dir[j][0];
                    int dy=p.second+dir[j][1];
                    if(dx<0||dx>=n||dy<0||dy>=n||grid[dx][dy]==1)   continue;
                    if(dx==n-1&&dy==n-1)    return step;
                    que.push({dx,dy});
                    grid[dx][dy]=1;
                }
            }
            step++;
        }
        return -1;
    }
};

四、被围绕的区域

• 题目：
  
• 题解：

    void solve(vector<vector<char>>& board) {
        int mr=board.size(),nc=board[0].size();
        if(mr<=1)   return ;
        for(int i =0;i<nc;i++){
            dfs(board,0,i,mr,nc);
            dfs(board,mr-1,i,mr,nc);
        }
        for(int i=0;i<mr;i++){
            dfs(board,i,0,mr,nc);
            dfs(board,i,nc-1,mr,nc);
        }
        for(int i=0;i<mr;i++){
            for(int j=0;j<nc;j++){
                if(board[i][j]=='J'){
                    board[i][j]='O';
                }else{
                    board[i][j]='X';
                }
            }
        }
    }
    void dfs(vector<vector<char>>&board,const int&x,const int&y,int&mr,int&nc){
        if(x<0||x>=mr||y<0||y>=nc||board[x][y]!='O')  return ;
        board[x][y]='J';
        dfs(board,x+1,y,mr,nc);
        dfs(board,x-1,y,mr,nc);
        dfs(board,x,y-1,mr,nc);
        dfs(board,x,y+1,mr,nc);
    }

五、所有可能的路径

• 题目:
  

class Solution {
public:
    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {
       stk.emplace_back(0);
        dfs(graph,0,graph.size()-1);
        return res;
    }
    void dfs(vector<vector<int>>&graph,int x,int n){
        if(x==n) {
            res.push_back(stk);
            return ;
        }
        for(auto&y:graph[x]){
            stk.emplace_back(y);
            dfs(graph,y,n);
            stk.pop_back();
        }
    }
    vector<vector<int>>res;
    vector<int>stk;

};