52.腐烂的橘子(学习)

在给定的 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.遍历整个网格，统计新鲜橘子的数量（freshOranges），并将所有腐烂橘子的坐标加入到一个队列（queue）中。
2.如果一开始就没有新鲜橘子（freshOranges === 0），则直接返回 0，因为没有橘子需要腐烂。

二、BFS 过程：
1.使用一个循环来执行 BFS，直到队列为空或没有新鲜橘子为止。
2.在每次循环中，处理当前队列中的所有腐烂橘子（即队列的当前层）。对于每个腐烂橘子，检查其四个方向上的相邻单元格：
3.如果相邻单元格是新鲜橘子（值为 1），则将其变为腐烂橘子（值为 2），并将其坐标加入队列中以便后续处理。
4.同时，将新鲜橘子的数量减一（freshOranges–）。
5.完成当前层的所有腐烂橘子的处理后，分钟数加一（minutes++），表示又过去了一分钟。

三、结果判断：
1.如果循环结束后，队列为空但仍有新鲜橘子（freshOranges > 0），则表示无法将所有新鲜橘子腐烂，返回 -1。
2.否则，返回分钟数 minutes，即直到网格中没有新鲜橘子为止所需的最小分钟数。

var orangesRotting = function (grid) {
    if (!grid.length || !grid[0].length) return 0;

    const directions = [[-1, 0], [1, 0], [0, -1], [0, 1]]; // 上下左右四个方向  
    const rows = grid.length;
    const cols = grid[0].length;
    let freshOranges = 0; // 记录新鲜橘子的数量  
    let queue = []; // 使用队列存储腐烂的橘子坐标  

    // 初始化队列，并统计新鲜橘子的数量  
    for (let i = 0; i < rows; i++) {
        for (let j = 0; j < cols; j++) {
            if (grid[i][j] === 1) {
                freshOranges++;
            } else if (grid[i][j] === 2) {
                queue.push([i, j]); // 将腐烂的橘子坐标加入队列  
            }
        }
    }

    if (freshOranges === 0) {
        // 如果没有新鲜橘子，则不需要任何时间  
        return 0;
    }

    let minutes = 0; // 记录分钟数  

    while (queue.length > 0 && freshOranges > 0) {
        const size = queue.length;

        for (let i = 0; i < size; i++) {
            const [row, col] = queue.shift(); // 取出队列中的一个腐烂橘子坐标  

            // 检查四个方向上的相邻单元格  
            for (const [dx, dy] of directions) {
                const newRow = row + dx;
                const newCol = col + dy;

                if (
                    newRow >= 0 &&
                    newRow < rows &&
                    newCol >= 0 &&
                    newCol < cols &&
                    grid[newRow][newCol] === 1
                ) {
                    // 如果找到新鲜橘子，则将其变为腐烂的橘子，并加入到队列中  
                    grid[newRow][newCol] = 2;
                    queue.push([newRow, newCol]);
                    freshOranges--; // 减少新鲜橘子的数量  
                }
            }
        }

        minutes++; // 每处理完一轮腐烂橘子，分钟数加1  
    }

    // 如果还有新鲜橘子剩下，则返回-1，否则返回分钟数  
    return freshOranges === 0 ? minutes : -1;
};