Java二进制矩阵中的最短路径leetcode

给你一个 n x n 的二进制矩阵 grid 中，返回矩阵中最短 畅通路径 的长度。如果不存在这样的路径，返回 -1 。

二进制矩阵中的 畅通路径 是一条从 左上角 单元格（即，(0, 0)）到 右下角 单元格（即，(n - 1, n - 1)）的路径，该路径同时满足下述要求：

        路径途经的所有单元格都的值都是 0 。
        路径中所有相邻的单元格应当在 8 个方向之一 上连通（即，相邻两单元之间彼此不同且共享一条边或者一个角）。
        畅通路径的长度 是该路径途经的单元格总数。

提示：

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

class Solution {
    
    

    public int shortestPathBinaryMatrix(int[][] grid) {
        int n = grid.length,m = grid[0].length;
        if(grid[0][0] != 0 || grid[n-1][m-1] != 0){
            return -1;
        }

        //八个方向
        int[][] dirs = {{0,1},{0,-1},{1,0},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1}}; 

        int PathLength = 0;

        Queue<int[]> q = new LinkedList<>();
        q.add(new int[]{0,0});
        grid[0][0] = 1;
         
        while( !q.isEmpty() ){
            int size = q.size();
            PathLength++;
            for(int i = 0;i < size;i++){
                int[] cur = q.poll();
                int curi = cur[0];
                int curj = cur[1];

                //到达终点返回
                if(curi == n - 1 && curj == m - 1){
                    return PathLength;
                }
                for(int j = 0;j < 8;j++){
                    int curii = curi + dirs[j][0];
                    int curjj = curj + dirs[j][1];
                    //越界或者已经走过或者不能走,跳过这一轮
                    if(curii < 0 || curjj < 0 || curii >= n || curjj >= m || grid[curii][curjj] != 0){
                        continue;
                    }
                    grid[curii][curjj] = 1;
                    q.add(new int[]{curii,curjj});
                }
            }
        }
        return -1;
    }
}

执行用时：10 ms, 在所有 Java 提交中击败了98.19%的用户

内存消耗：42.6 MB, 在所有 Java 提交中击败了49.26%的用户