LeetCode 1091. 二进制矩阵中的最短路径--BFS模拟

1091. 二进制矩阵中的最短路径

在一个 N × N 的方形网格中，每个单元格有两种状态：空（0）或者阻塞（1）。

一条从左上角到右下角、长度为 k 的畅通路径，由满足下述条件的单元格 C_1, C_2, …, C_k 组成：

相邻单元格 C_i 和 C_{i+1} 在八个方向之一上连通（此时，C_i 和 C_{i+1} 不同且共享边或角）
C_1 位于 (0, 0)（即，值为 grid[0][0]）
C_k 位于 (N-1, N-1)（即，值为 grid[N-1][N-1]）
如果 C_i 位于 (r, c)，则 grid[r][c] 为空（即，grid[r][c] == 0）

返回这条从左上角到右下角的最短畅通路径的长度。如果不存在这样的路径，返回 -1 。

示例 1：

输入：[[0,1],[1,0]]
输出：2

示例 2：
输入：[[0,0,0],[1,1,0],[1,1,0]]
输出：4

提示：

1 <= grid.length == grid[0].length <= 100
grid[i][j] 为 0 或 1

题解：

就是BFS模拟，没啥算法思想，特判下开始的grid[0][0]是否为0，一开始被这个坑了。。。。

AC代码

class Solution {
public:
    struct Node
    {
        int x,y,dp;
    };
    bool vis[110][110];
    queue<Node>q;
    int XX[8]={1,-1,1,-1,0,0,1,-1};
    int YY[8]={1,-1,-1,1,1,-1,0,0};
    int bfs(vector<vector<int>>& grid)
    {
        if(grid[0][0]==1)return -1;
        if(grid.size()==1)return 1;
        int n=grid.size();
        Node t;
        t.x=0,t.y=0,t.dp=1;
        while(!q.empty())q.pop();
        memset(vis,0,sizeof(vis));
        q.push(t);
        vis[0][0]=true;
        while(!q.empty())
        {
            t=q.front();
            q.pop();
            for(int i=0;i<8;i++)
            {
                Node w;
                w.x=t.x+XX[i];
                w.y=t.y+YY[i];
                w.dp=t.dp+1;
                if(w.x<0||w.x>=n)continue;
                if(w.y<0||w.y>=n)continue;
                if(vis[w.x][w.y])continue;
                if(grid[w.x][w.y]==1)continue;
                if(w.x==n-1&&w.y==n-1)return w.dp;
                vis[w.x][w.y]=true;
                q.push(w);
            }
        }
        return -1;
    }
    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
        return bfs(grid);
    }
};