LeetCode热题100 腐烂的橘子

题目描述

在给定的 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

思路

进行多源广度优先搜索，多个起点视为同一层。

代码

cpp 复制代码

class Solution {
public: 
    // 定义四个方向
    int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
    int orangesRotting(vector<vector<int>>& grid) {
        // 分钟数
        int res = 0;
        // 新鲜橘子个数
        int cnt = 0;
        // 存储烂橘子的位置
        queue<array<int, 2>>q;
        // 获取矩阵边界
        int n = grid.size(), m = grid[0].size();
        for(int i = 0; i < n ;++i)
        {
            for(int j = 0; j < m; ++j)
            {
                if(grid[i][j] == 1) ++cnt;
                else if(grid[i][j] == 2) 
                {
                    q.push({i, j});
                    grid[i][j] = 0;
                }
            }
        }
        
        // 进行层次遍历
        int qz = q.size();
        while(cnt && !q.empty())
        {
            auto [x, y] = q.front();
            q.pop();
            --qz;

            for(int i = 0; i < 4; ++i)
            {
                int xx= x + dx[i], yy = y + dy[i];
                if(xx >= 0 && xx < n && yy >=0 && yy < m && grid[xx][yy] == 1)
                {
                    --cnt;
                    grid[xx][yy] = 0;
                    q.push({xx, yy});
                }
            }

            // 每层结束或者全部腐烂, ++res
            if(qz != 0 && cnt == 0)
            {
                ++res;
            }
            else if(qz == 0)
            {
                ++res;
                qz = q.size();    
            }
        }

        // 返回分钟数
        if(cnt) return -1;
        else return res;
    }
};