矩阵BFS

leetcode 1091矩阵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 。

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/shortest-path-in-binary-matrix

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution {
    private static int[][] dir = {{0, 1}, {0, -1}, {1, -1}, {1, 0}, {1, 1}, {-1, -1}, {-1, 0}, {-1, 1}};
    private int m, n;

    public int shortestPathBinaryMatrix(int[][] grid) {
        m = grid.length;
        n = grid[0].length;
        if (grid[0][0] == 1 || grid[m - 1][n - 1] == 1) return -1;
        grid[0][0] = 1;
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{0, 0});
        while (!queue.isEmpty()) {
            int[] tmp = queue.poll();
            for (int[] d : dir) {
                int x = tmp[0] + d[0];
                int y = tmp[1] + d[1];

                if (judge(x, y) && grid[x][y] == 0) {
                    queue.add(new int[]{x, y});
                    grid[x][y] = grid[tmp[0]][tmp[1]] + 1;
                }
            }

        }
        return grid[m - 1][n - 1] == 0 ? -1 : grid[m - 1][n - 1]; // 如果最后终点的
    }

    private boolean judge(int x, int y) {
        return x >= 0 && x < m && y >= 0 && y < n;
    }
}