你绝对能懂的“腐烂的橘子”解法

题目来源：Leetcode腐烂的橘子

一.题目

在给定的网格中，每个单元格可以有以下三个值之一：

• 值 0 代表空单元格；
• 值 1 代表新鲜橘子；
• 值 2 代表腐烂的橘子。

每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。
返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1。

示例 1：
输入：[[2,1,1],[1,1,0],[0,1,1]]
输出： 4

示例： 2
输入： [[2,1,1],[0,1,1],[1,0,1]]
输出： -1
解释： 左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个正向上。

示例 3：
输入： [[0,2]]
输出： 0
解释： 因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。

二.解题思路

根据题意，网格中所有的腐烂橘子会在同一时间内向上，下，左，右污染新鲜的橘子，在一分钟后，新被污染的腐烂橘子也会继续向四周污染，因此这是一道广度优先搜索的题。(如读者对BFS不了解的，这里推荐一篇文章请点我)
在了解了BFS的原理后，该题的求解思路已经十分清晰，这里以伪代码的形式给出其大概思路：

创建一个队列queue(队列中每个元素为一对坐标值)
queue初始化(将二维数组中所有腐烂橘子的坐标入队)
while queue is not Empty:
	(x,y) = queue.front() #获取队头元素
	if (x,y)的上/下/左/右存在新鲜橘子:
		新鲜橘子被污染(其对应网格处的值为(x,y)处的值 + 1)
		新被污染的橘子的坐标入队
if 网格中还有新鲜橘子:
	return -1
maxvalue = max(网格)#寻找网格中的最大值
if maxvalue <=2:#网格中不存在腐烂橘子|网格中没有新鲜橘子
	return 0
return maxvalue - 2 #获取污染需要的时间

说明：根据队列性质，不同层的顺序会按层次顺序一层一层的去腐蚀其它橘子，每一层被腐蚀橘子的值为上一层腐烂橘子的值加1，所以同一层的复燃橘子值相同，不同层的腐烂橘子值不相同，用腐烂橘子的最大值减去2，我们就可知道腐烂橘子腐蚀所有的新鲜橘子用了多久了。

2.1.腐蚀过程演示(借原题例1来举个栗子)

初始网格

第一层腐蚀结果

第二层腐蚀结果

第三层腐蚀结果

第四次腐蚀结果

2.2.如何构建队列

经过上述的介绍，相信你对解题思路基本上了解了，那么我们该如何构建队列呢？我第一个想到的就是借助python中的列表了。这里就该亮出列表中两个杀招函数了：

• append()：用于往列表末尾添加元素；
• pop()：一般用于取出并返回列表末尾的元素，当为该函数指定索引的时候就可以用来取出指定位置的元素并返回改元素，因此根据队列FIFO的特性，这里直接使用pop(0)取出并返回列表头部元素即可；

通过上述两个函数，pop(0)用于取出队列头部元素，append(用于)往队列尾部添加元素，一个队列都构造完成了。

三.代码

根据上述伪代码的思路，这里给出详细代码

from typing import List

class Solution:
    def orangesRotting(self, grid: List[List[int]]) -> int:
        #获取行数，列数
        m = len(grid)
        n = len(grid[0])
        queue = []  #定义队列
        count = 0   #统计新鲜橘子的数量
        #初始化队列
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 1:
                    count +=1
                if grid[i][j] == 2:
                    queue.append([i,j])
        
        #进行广度优先搜索
        while queue != []:
            x,y = queue.pop(0)
            if x - 1 >= 0 and grid[x-1][y] == 1:
                queue.append([x-1,y])
                count -= 1
                grid[x-1][y] = grid[x][y] + 1
            if x + 1 < m and grid[x+1][y] == 1:
                queue.append([x+1,y])
                count -= 1
                grid[x+1][y] = grid[x][y] + 1
            if y - 1 >=0 and grid[x][y-1] == 1:
                queue.append([x,y-1])
                count -= 1
                grid[x][y-1] = grid[x][y] + 1
            if y + 1 < n and grid[x][y+1] == 1:
                queue.append([x,y+1])
                count -= 1
                grid[x][y+1] = grid[x][y] + 1
        
        #有新鲜橘子无法被腐蚀
        if count > 0:
            return -1
        #寻找腐烂橘子中的最大值
        max_value = max(max(row) for row in grid)
        #原队列中不存在新鲜橘子或不存在腐烂橘子
        if max_value < 2:
            return 0
        return max_value - 2

以上便是该题解题的全过程，要是觉得不错的话，可以点个赞支持一下博主，你们的支持是博主创作的动力源泉。