【LeetCode热题100】994. 腐烂的橘子（图论）

一.题目要求

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

• 值 0 代表空单元格；
• 值 1 代表新鲜橘子；
• 值 2 代表腐烂的橘子。
• 每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。

返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。

二.题目难度

中等

三.输入样例

示例 1：

输入：grid = [[2,1,1],[1,1,0],[0,1,1]]
输出：4

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

示例 3：

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

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 10
• grid[i][j] 仅为 0、1 或 2

四.解题思路

BFS，把腐烂的橘子入队，处理完一层看是否有后续来增加time
题解中有模板

五.代码实现

C++

class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) {
        int time = 0;
        int m = grid.size(), n = grid[0].size();
        queue<pair<int, int>> bad_orange;

        vector<pair<int, int>> directions = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
            {
                if(grid[i][j] == 2)
                    bad_orange.push(pair(i, j));
            }
        }

        while(!bad_orange.empty())
        {
            /*
                BFS 判断每层是否遍历结束模板：

                //（1）
                while(队列非空)
                {
                    //（2）
                    int 当前层长度 = 队列长度;

                    //（3）
                    for(i = 0; i < 当前层长; i++)
                    {
                        //...
                    }

                    //（4）*可选
                    //一些后处理，例如本体求时间
                    if(队列中还有元素) time++;
                }
            
            */
            int crt_layer_size = bad_orange.size();
            
            for(int i = 0; i < crt_layer_size; i++)
            {
                auto [row, col] = bad_orange.front();

                bad_orange.pop();

                for(const auto& [r, l] : directions)
                {
                    if(row + r >= 0 && row + r < m && col + l >= 0 && col + l < n)
                    {
                        if(grid[row + r][col + l] == 1)
                        {
                            grid[row + r][col + l] = 2;
                            bad_orange.push(pair(row + r, col + l));
                        }
                    }
                }
            }
            if(!bad_orange.empty()) time++;
        }

        for(int i = 0; i < m; i++)
        {
            if(ranges::find(grid[i], 1) != grid[i].end())
                return -1;
        }
        return time;
    }
};

Python

class Solution:
    def orangesRotting(self, grid: List[List[int]]) -> int:
        m, n, time = len(grid), len(grid[0]), 0
        que = []
        directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
        for i in range(m):
            for j in range(n):
                if grid[i][j] == 2:
                    que.append((i, j, time))
        
        while que:
            i, j, time = que.pop(0)
            for di, dj in directions:
                if 0 <= i + di < m and 0 <= j + dj < n and grid[i + di][j + dj] == 1:
                    grid[i + di][j + dj] = 2
                    que.append((i + di, j + dj, time + 1))
        
        for row in grid:
            if 1 in row: return -1
        return time

六.题目总结

–