小黑代码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