【LeetCode】每日一题：994.腐烂的橘子

在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：
值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。
返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。

只想到了类似模拟的bfs，没想到答案也是这样做的，感觉有一点点蠢，不过看了官方题解的做法还是有一些可以学习的东西的。

AC代码

class Solution:
    def orangesRotting(self, grid: List[List[int]]) -> int:
        m = len(grid)
        n = len(grid[0])
        queue = []
        rott_flag = 0
        fresh_flag = 0
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 2:
                    rott_flag = 1
                    queue.append((i, j))
                if grid[i][j] == 1:
                    fresh_flag = 1
        if rott_flag  == 0 and fresh_flag == 1: return -1 
        if fresh_flag == 0: return 0
        res = 0
        while queue:
            length = len(queue)
            for i in range(length):
                q = queue[0]
                queue.remove(q)
                if 0 <= q[0] - 1:
                    if grid[q[0] - 1][q[1]] == 1:
                        queue.append((q[0] - 1, q[1]))
                        grid[q[0] - 1][q[1]] = 2
                if 0 <= q[1] - 1:
                    if grid[q[0]][q[1] - 1] == 1:
                        queue.append((q[0], q[1] - 1))
                        grid[q[0]][q[1] - 1] = 2
                if q[0] + 1 < m:
                    if grid[q[0] + 1][q[1]] == 1:
                        queue.append((q[0] + 1, q[1]))
                        grid[q[0] + 1][q[1]] = 2
                if q[1] + 1 < n:
                    if grid[q[0]][q[1] + 1] == 1:
                        queue.append((q[0], q[1] + 1))
                        grid[q[0]][q[1] + 1] = 2
            res += 1
        
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 1:
                    return -1
        return res - 1            

官方题解

官方题解的主要思路其实是一致的，但是写起来就干净很多。首先是遍历确定queue的初始状态的写法，用两个enumerate可以简写很多；生成器的写法也很值得学习，整体代码很清爽。以及事实上只需要判断最后是否有新鲜橘子即可，不需要在上面多判断一次。

class Solution:
    def orangesRotting(self, grid: List[List[int]]) -> int:
        R, C = len(grid), len(grid[0])

        # queue - all starting cells with rotting oranges
        queue = collections.deque()
        for r, row in enumerate(grid):
            for c, val in enumerate(row):
                if val == 2:
                    queue.append((r, c, 0))

        def neighbors(r, c) -> (int, int):
            for nr, nc in ((r - 1, c), (r, c - 1), (r + 1, c), (r, c + 1)):
                if 0 <= nr < R and 0 <= nc < C:
                    yield nr, nc

        d = 0
        while queue:
            r, c, d = queue.popleft()
            for nr, nc in neighbors(r, c):
                if grid[nr][nc] == 1:
                    grid[nr][nc] = 2
                    queue.append((nr, nc, d + 1))

        if any(1 in row for row in grid):
            return -1
        return d