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：

示例 2：

 

提示：

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

 

算法：

BFS

class Solution {
public:
    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {    

        int m = grid.size();
        if(m == 0 || grid[m-1][m-1] == 1 || grid[0][0] == 1)
            return -1;
        vector<vector<int> >visit(m, vector<int>(m));
        int a = bfs(grid, m, visit);
        return a;
    }
    
    
    
    int bfs(vector<vector<int>>& grid, int & m, vector<vector<int>>& visit)
    {
        queue<node>que;
        que.push(node(0,0,1));

        int dx[] = { -1, -1, -1, 0, 1, 1, 1, 0};
        int dy[] = { -1, 0, 1, 1, 1, 0, -1, -1};
    
        while(!que.empty())
        {
            
            node value = que.front();
            que.pop();
            if(value.x == m-1 && value.y==m-1)
                return value.d;
            cout<<value.x<<" "<<value.y<<" "<<value.d<<endl;
            for(int p = 0; p<8; p++)
            {
                int nx = value.x + dx[p];
                int ny = value.y + dy[p];
                if( nx >=0 && nx < m && ny >=0 && ny <m && grid[nx][ny]==0 && visit[nx][ny] == 0)
                {
                    visit[nx][ny] = 1;
                    que.push(node(nx, ny, value.d+1));
                }
            }

        }
        return -1;
    }
    
    struct node
    {
        int x, y, d;
        node(int a, int b, int c)
        {
            x = a;
            y = b;
            d = c;
        }
    };

};