小黑今天上午着急忙慌实习公司楼下笔试，晚上准备和尚香疯狂星期四明天继续现场笔试的leetcode之旅:1091. 二进制矩阵中的最短路径

最新推荐文章于 2025-11-01 10:57:47 发布

原创最新推荐文章于 2025-11-01 10:57:47 发布 · 513 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #职场和发展

小黑的日常leetcode之旅专栏收录该内容

266 篇文章

订阅专栏

文章讲述了两种不同的方法来解决在二进制矩阵中寻找从起点到终点最短路径的问题。第一种是基于广度优先搜索的队列操作，第二种是利用A*算法优化搜索效率。两种方法都涉及到判断矩阵中的障碍物和边界条件，并且在遇到终点时返回路径长度。此外，文章还穿插了作者日常生活的点滴。

小黑代码1

class Solution:
    def shortestPathBinaryMatrix(self, grid: List[List[int]]) -> int:
        # 一定无解的情况
        if grid[0][0] == 1 or grid[-1][-1] == 1:
            return -1
        # 矩阵长度
        n = len(grid)
        # 起点即终点
        if n == 1:
            return 1
        # 访问集合
        seen = {(0, 0)}
        # 初始化队列
        q = collections.deque([[(0,0), 1]])
        # 开始进行队列操作
        while q:
            # 出队
            top = q.popleft()
            pos = top[0]
            dis = top[1]
            # 八个方向尝试
            for di in [[1, 0], [0, 1], [1, 1], [-1, 0], [0, -1], [-1, -1], [1, -1], [-1, 1]]:
                # 构造坐标
                pos_x = pos[0] + di[0]
                pos_y = pos[1] + di[1]
                # 判断是否出界以及有障碍物
                if 0 <= pos_x < n and 0 <= pos_y < n and (pos_x, pos_y) not in seen and not grid[pos_x][pos_y]:
                    # 到达终点
                    if pos_x == pos_y == n - 1:
                        return dis + 1
                    q.append(((pos_x, pos_y), dis + 1))
                    seen.add((pos_x, pos_y))
        return -1

在这里插入图片描述

小黑代码2

# A*算法类
class Astar(object):
    def __init__(self, status, target, g):
        self.status = status
        self.target = target
        self.g = g
        self.h = Astar.getH(status, target)
        self.f = self.g + self.h
    @staticmethod
    def getH(status, target):
        print(status)
        dis_x = abs(status[0]-target[0])
        dis_y = abs(status[1]-target[1])
        
        return max(dis_x, dis_y)
    # 排序函数
    def __lt__(self, other):
        if self.f == other.f:
            return self.g < other.g
        return self.f < other.f
class Solution:
    def shortestPathBinaryMatrix(self, grid: List[List[int]]) -> int:
        # 一定无解的情况
        if grid[0][0] == 1 or grid[-1][-1] == 1:
            return -1
        # 数组长度
        n = len(grid)
        # 起点即是终点的情况
        if n == 1:
            return 1
        # 初始化优先队列
        q = [Astar((0, 0), (n-1, n-1), 1)]
        # 访问数组
        visited = set()
        # 开始进行A*算法迭代
        while q:
            # “假设距离”最近的出队
            top = heapq.heappop(q)
            status = top.status
            g = top.g
            if status in visited:
                continue
            visited.add(status)
            # 8个方向
            for di in [(-1,-1), (1,0), (0,1), (-1,0), (0,-1), (1,1), (1,-1), (-1,1)]:
                # 构造心得坐标
                new_pos = [0, 0]
                new_pos[0] = status[0] + di[0]
                new_pos[1] = status[1] + di[1]
                new_pos = (new_pos[0], new_pos[1])
                # 准入条件：未出界+无障碍+没走过
                if 0 <= new_pos[0] < n and 0 <= new_pos[1] < n and not grid[new_pos[0]][new_pos[1]]:
                    # 是否到终点
                    if new_pos[0] ==new_pos[1] == n - 1:
                        return g + 1
                    # 入队列
                    heapq.heappush(q, Astar(new_pos, (n-1, n-1), g + 1))
        return -1