力扣每日一题：逃离火灾

时间打败 100%   内存打败100% 的超强解法，解决力扣2258 逃离火灾
2258. 逃离火灾
给你一个下标从 0 开始大小为 m x n 的二维整数数组 grid ，
它表示一个网格图。每个格子为下面 3 个值之一：
0 表示草地。
1 表示着火的格子。
2 表示一座墙，你跟火都不能通过这个格子。
一开始你在最左上角的格子 (0, 0) ，
你想要到达最右下角的安全屋格子 (m - 1, n - 1) 。每一分钟，
你可以移动到 相邻 的草地格子。
每次你移动 之后 ，着火的格子会扩散到所有不是墙的 相邻 格子。
请你返回你在初始位置可以停留的 最多 分钟数，且停留完这段时间后你还能安全到达安全屋。如果无法实现，请你返回 -1 。如果不管你在初始位置停留多久，你 总是 能到达安全屋，请你返回 109 。
注意，如果你到达安全屋后，火马上到了安全屋，这视为你能够安全到达安全屋。
如果两个格子有共同边，那么它们为 相邻 格子。

广搜解法，此解法为某大佬所写，这里只做分享，同时加上自己的一些理解注释

class Solution(object):
    def maximumMinutes(self, grid):
        m, n, inf = len(grid), len(grid[0]), 20001
        lstp, lstp_, lstf, lstf_, step = [(0, 0)], [], [], [], 1
        for x in range(m):                          # 预处理 grid
            for y in range(n):
                if   grid[x][y] == 0: grid[x][y] = [0, inf]
                elif grid[x][y] == 1:
                    grid[x][y] = [0, -1]
                    lstf.append((x, y))
                else: grid[x][y] = [-1, -1]
        while True:
            if lstf and (m - 1, n - 1) not in lstf:
                for fx, fy in lstf:                 # 广度遍历 火的走步
                    for x, y in ((fx - 1, fy), (fx, fy - 1), \
                                 (fx, fy + 1), (fx + 1, fy)):
                        if 0 <= x < m and 0 <= y < n and grid[x][y][1] == inf:
                            grid[x][y][1] = step
                            lstf_.append((x, y))
                lstf, lstf_ = lstf_, []
            if lstp and (m - 1, n - 1) not in lstp:
                for px, py in lstp:                 # 广度遍历 人的走步
                    for x, y in ((px - 1, py), (px, py - 1), (px, py + 1), \
                                 (px + 1, py)):
                        if 0 <= x < m and 0 <= y < n and grid[x][y][0] == 0 \
                                and ((x, y)\
                            == (m - 1, n - 1) or step < grid[x][y][1]):
                            grid[x][y][0] = step
                            lstp_.append((x, y))
                lstp, lstp_ = lstp_, []
            if (lstp == [] or (m - 1, n - 1) in lstp) and (lstf == [] or \
                (m - 1, n - 1) in lstf): break    # 火和人，均到达终点或无路可走，则跳出循环，进行总结，计算最终结果
            step += 1
        if lstp == []: return -1                    # 人无路可走，返回 -1
        if lstf == []: return 1000000000            # 火无路可走，返回 1000000000
        return grid[m - 1][n - 1][1] - grid[m - 1][n - 1][0] \
              - ((0 < grid[m - 2][n - 1][0] \
             < grid[m - 2][n - 1][1] < inf and \
            (grid[m - 1][n - 2][0] in (-1, 0) or \
             grid[m - 1][n - 2][1] != inf)) or \
            (0 < grid[m - 1][n - 2][0] < grid[m - 1][n - 2][1] < inf \
             and (grid[m - 2][n - 1][0] in (-1, 0) or \
                grid[m - 2][n - 1][1] != inf)))   # 计算人可延时的时间

可以说是很强