LeetCode 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 。

解法

实际上就是使用BFS进行 广度优先搜索。找到最短的路径
同时还有动态规划的相关思想

class Solution {

     private static int[][] directions = {{0,1}, {0, -1}, {1, -1}, {1, 0}, {1, 1}, {-1, -1}, {-1, 0}, {-1, 1}};
     private int row, col;

    
    public int shortestPathBinaryMatrix(int[][] grid) {
        row = grid.length;
        col = grid[0].length;
        if(grid[0][0] == 1 || grid[row - 1][col - 1] == 1) return -1;
        Queue<int[] > queue = new LinkedList<>();
        queue.offer(new int[] {0,0}); //这里队列中放的是一个2长度的数组，用来存放当前位置的x，y坐标
        grid[0][0] = 1;  //grid数组本来是放0或1，用来表示空或者阻塞，然后当是可以走的时候，
        //将当前位置赋值，表示为从左上角到当前位置的最短路径。用来记录最短路径的。
        //这里起点，所以最短路径为1.
        while (!queue.isEmpty() && grid[row-1][col-1] == 0) { //队列不为空，且终点是空的
            int[] temp = queue.remove();
            int preLength = grid[temp[0]][temp[1]]; //记录当前位置的最短路径
            for (int i = 0; i < 8; i++) { //八个方位的循环
                int newX = temp[0] + directions[i][0];
                int newY = temp[1] + directions[i][1];
                if (inGrid(newX, newY) && grid[newX][newY] == 0) { //如果走的位置不出界且 能走且是没有被访问过
                    queue.offer(new int[] {newX,newY});
                    grid[newX][newY] = preLength + 1;  //下一个位置的最短路径
                }
            }
        }
        return grid[row-1][col-1] != 0 ? grid[row-1][col-1] : -1;
    }
    public boolean inGrid (int x, int y) { //判断xy是否出界
        if (x >= 0 && x < row && y >= 0 && y < col) return true;
        return false;
    }
}
 

复杂度分析

时间复杂度为O(n)，因为每个元素遍历了一次，n为元素的个数。
空间复杂度为O(k)，k为过程中队列的最大元素个数。

优化

这里的队列还是先进先出的，但是我们可以改为是优先队列。将最为可能是最短路径的走法先出队。可以提高速度。但是本质上，还是要将所有位置 都需要进队的。只是出队的时候通过优先级来出队。