LeetCode 算法：腐烂的橘子 c++

原题链接🔗：腐烂的橘子
难度：中等⭐️⭐️

题目

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

题解

1. 解题思路：

LeetCode 上的 “腐烂的橘子” 问题是一个模拟问题，属于中等难度。这个问题的目的是模拟一个过程，其中一些橘子可能开始腐烂，并且腐烂的橘子可以影响周围的橘子，使它们也腐烂。

问题描述： 在一个给定的二维数组中，每个单元格可以包含一个未腐烂的橘子（用 1 表示）或者一个腐烂的橘子（用 2 表示）。每分钟，任何与腐烂的橘子相邻的未腐烂的橘子都会腐烂。注意，腐烂的橘子不会继续腐烂。你需要找出使所有橘子腐烂所需的最少分钟数。

解题思路：

• 分析问题：首先，我们需要理解问题的要求和橘子腐烂的规则。
• 初始化：记录所有腐烂橘子的位置和数量。
• 模拟过程：
  • 从腐烂的橘子开始，每分钟检查它们周围的橘子，如果它们是未腐烂的，就将它们标记为腐烂。
  • 同时记录下所有未腐烂的橘子，因为它们可能在下一轮被腐烂的橘子影响。
• 更新状态：每分钟结束后，更新所有腐烂橘子的状态，并将之前未腐烂的橘子标记为腐烂。
• 循环结束条件：如果所有的橘子都腐烂了，结束循环。
• 返回结果：返回循环的轮数，即所需的最少分钟数。

算法步骤：

• 记录初始状态：找到所有腐烂橘子的位置，并记录未腐烂橘子的数量。
• 模拟腐烂过程：
  • 对于每个腐烂的橘子，检查其上下左右四个方向的橘子。
  • 如果发现未腐烂的橘子，将其标记为腐烂，并更新未腐烂橘子的计数。
• 更新时间：每分钟结束时，所有标记为腐烂的橘子都变为腐烂状态。
• 检查结束条件：如果未腐烂的橘子计数为0，即所有橘子都已腐烂，返回当前分钟数。
• 重复步骤2-4，直到所有橘子都腐烂。

2. c++ demo：

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) {
        int row = grid.size();
        if (row == 0) return 0;
        int col = grid[0].size();
        queue<pair<int, int>> rotten;
        vector<vector<int>> fresh(row, vector<int>(col, 0));
        int totalFresh = 0, minutes = 0;

        // 计算初始腐烂和新鲜橘子的数量
        for (int i = 0; i < row; ++i) {
            for (int j = 0; j < col; ++j) {
                if (grid[i][j] == 2) {
                    rotten.push({ i, j });
                }
                else if (grid[i][j] == 1) {
                    totalFresh++;
                    fresh[i][j] = 1;
                }
            }
        }

        // 四个方向的移动
        vector<pair<int, int>> directions = { {0, 1}, {1, 0}, {0, -1}, {-1, 0} };

        while (!rotten.empty() && totalFresh > 0) {
            int size = rotten.size();
            for (int k = 0; k < size; ++k) {
                auto [x, y] = rotten.front();
                rotten.pop();
                for (auto& dir : directions) {
                    int newX = x + dir.first, newY = y + dir.second;
                    if (newX >= 0 && newX < row && newY >= 0 && newY < col && fresh[newX][newY] == 1) {
                        fresh[newX][newY] = 0;
                        totalFresh--;
                        rotten.push({ newX, newY });
                    }
                }
            }
            minutes++;
        }

        return totalFresh == 0 ? minutes : -1;
    }
};

int main() {
    Solution solution;
    vector<vector<int>> grid = {
        {2, 1, 1},
        {1, 1, 0},
        {0, 1, 1}
    };
    cout << "Minimum minutes required for all oranges to rot: " << solution.orangesRotting(grid) << endl;
    return 0;
}

• 输出结果：

Minimum time to rot all oranges: 4

3. 代码仓库地址：orangesRotting