leetcode1091. 二进制矩阵中的最短路径（bfs）

在一个 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 。

代码

class Solution {
    public int shortestPathBinaryMatrix(int[][] grid) {
           if(grid[0][0]==1) return -1;
        int[][] dir=new int[][]{{-1,0},{1,0},{0,1},{0,-1},{1,1},{1,-1},{-1,1},{-1,-1}};
        Queue<int[]> queue=new LinkedList<>();
        int n=grid.length;
        int level=1;
        queue.add(new int[]{0,0});
                boolean[][] check=new boolean[n][n];
        check[0][0]=true;
        while (!queue.isEmpty())
        {

            int size=queue.size();
            for(int i=0;i<size;i++)
            {
                int[] temp=queue.poll();
                int x=temp[0],y=temp[1];
                if(x==n-1&&y==n-1) return level;
                for(int[] d:dir)
                {
                    int nextX=x+d[0],nextY=y+d[1];
                    if(bound(nextX,nextY,n,n)&&grid[nextX][nextY]!=1&&!check[nextX][nextY])
                    {
                        queue.add(new int[]{nextX,nextY});check[nextX][nextY]=true;
                    }
                }
            }
        level++;
        }
        return -1;
    }
        public boolean bound(int x,int y,int n,int m){
        return x>=0&&x<n&&y>=0&&y<m;
    }
}