190.（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

思路：

广度优先遍历

代码：

class Solution {
public:
    int shortestPathBinaryMatrix(vector<vector<int>>& grid) {
        int N=grid.size();
        if(grid[N-1][N-1]==1||grid[0][0]==1)return -1;
        if(N==1&&grid[0][0]==0)return 1;
        queue<vector<int>>q;
        vector<int> loc(3),temp(3);
        int disx[8]={1,-1,0,0,1,1,-1,-1};
        int disy[8]={0,0,1,-1,1,-1,1,-1};
        int x,y;
        loc[0]=loc[1]=0;
        loc[2]=1;
        q.push(loc);
        while(!q.empty())
        {
            temp=q.front();
            q.pop();
            for(int i=0;i<8;i++)
            {
                x=temp[0]+disx[i];
                y=temp[1]+disy[i];
                if(x>=N||x<0||y>=N||y<0||grid[x][y]==1)continue;
                if(x==N-1&&y==N-1)return temp[2]+1;
                grid[x][y]=1;
                q.push(vector<int>{x,y,temp[2]+1});
            }
        }
        return -1;
    }
};

执行效率：

执行用时：212 ms, 在所有 C++ 提交中击败了23.39%的用户

内存消耗：26.5 MB, 在所有 C++ 提交中击败了32.59%的用户