LeetCode 1091. Shortest Path in Binary Matrix【BFS,A星】中等

最新推荐文章于 2023-09-05 14:45:28 发布

memcpy0

最新推荐文章于 2023-09-05 14:45:28 发布

阅读量832

点赞数

分类专栏： LeetCode # BFS/DFS 文章标签： leetcode 宽度优先算法

本文链接：https://blog.csdn.net/myRealization/article/details/130893597

版权

本文属于「征服LeetCode」系列文章之一，这一系列正式开始于2021/08/12。由于LeetCode上部分题目有锁，本系列将至少持续到刷完所有无锁题之日为止；由于LeetCode还在不断地创建新题，本系列的终止日期可能是永远。在这一系列刷题文章中，我不仅会讲解多种解题思路及其优化，还会用多种编程语言实现题解，涉及到通用解法时更将归纳总结出相应的算法模板。

为了方便在PC上运行调试、分享代码文件，我还建立了相关的仓库：https://github.com/memcpy0/LeetCode-Conquest。在这一仓库中，你不仅可以看到LeetCode原题链接、题解代码、题解文章链接、同类题目归纳、通用解法总结等，还可以看到原题出现频率和相关企业等重要信息。如果有其他优选题解，还可以一同分享给他人。

由于本系列文章的内容随时可能发生更新变动，欢迎关注和收藏征服LeetCode系列文章目录一文以作备忘。

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

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

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

畅通路径的长度 是该路径途经的单元格总数。

示例 1：

输入：grid = [[0,1],[1,0]]
输出：2

示例 2：

输入：grid = [[0,0,0],[1,1,0],[1,1,0]]
输出：4

示例 3：

输入：grid = [[1,0,0],[1,1,0],[1,1,0]]
输出：-1

提示：

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

解法1 BFS

使用宽度优先算法，对八个方向一层层的搜索，从出发点开始，第一次遍历到终点时经过的那条路径就是最短的路径。因为这条路径没有多绕一个不相关节点，所以它是最短的，也符合题目最短畅通路径。

要注意的是，出发点和目的地都可能是 $1$ ，这时直接返回 $- 1$ 表示不可通过即可。

class Solution {
   
    public int shortestPathBinaryMatrix(int[][] grid) {
   
        int n = grid.length;
        if (grid[0][0] == 1 || grid[n - 1][n - 1] == 1) return -1; // 不可能出发或到达
        if (n <= 2) return n; // 1x1 2x2
        var q = new ArrayDeque<Integer>();
        int[][] d = {
   {
   0, 1}, {
   0, -1}, {
   1, 0}, {
   -1, 0}, {
   -1, -1}, {
   -1, 1}, {
   1, -1}, {
   1, 1}}; 
        q.offer(0);
        grid[0][0] = 1;
        int step = 1;
        while (!q.isEmpty()) {
   
            int size = q.size();
            for (int i = 0; i < size; ++i) {
   
                int u = q.poll();
                int x = u / n, y = u % n;
                if (x == n - 1 && y == n - 1) return step;
                for (int j = 0; j < 8; ++j) {
   
                    int tx = x + d[j][0], ty = y + d[j][1];
                    if (tx >= 0 && tx < n && ty >= 0 && ty < n && grid[tx][ty] == 0) {
   
                        q.offer(tx * n + ty);  
                        grid[tx][ty] = 1;
                    }
                }
            }
            ++step;
        }
        return -1;
    }
}

复杂度分析：

时间复杂度： $O(n^2)$ ，为二进制矩阵的大小。
空间复杂度： $O(n^2)$

解法2 A* Search启发式搜索

在说明 A* 算法前，先将上述代码改造成「可以延伸出 A* 算法」的形式：

class Solution {
   
    static class Node {
   
        public int x, y;
        public int step;
        public Node(int start, int end, int step) {
   
            this.x = start;
            this.y = end;
            this.step = step;
        }
    };
    private int[][] d = {
   {
   0, 1}, {
   0, -1}, {
   1,