Leecode热题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

本题的解法是图的广度优先遍历，就是一层一层的感染，上代码了，不懂的私信或者留言

class Solution {
    public int orangesRotting(int[][] grid) {
        /**如果就一个格子，是1就是-1，不是1就是0 */
        if(grid.length == 1 && grid[0].length == 1) {
            return grid[0][0] == 1? -1 : 0;
        }
        /**其他的情况我们使用广度优先遍历解题，如果遇到腐烂的橘子，就把这个位置加入队列，然后每次取出队列里的然后把它周围的新鲜的感染
        并入队，直到队列为空，每感染一层我们count++，现在我们先做第一步，第一步是统计一下有多少个新鲜的橘子还有把当前的腐烂的橘子入队*/
        Queue<int[]> queue = new LinkedList<>();
        /**freshCount表示目前的新鲜橘子的数量*/
        int freshCount = 0;
        for(int i = 0; i < grid.length; i++) {
            for(int j = 0; j < grid[i].length; j++) {
                /**腐烂的入队，新鲜的统计数量，空单元格什么也不做 */
                if(grid[i][j] == 2) {
                    queue.offer(new int[]{i, j});
                } else if(grid[i][j] == 1) {
                    freshCount ++;
                }
            }
        }
        /**如果压根没有新鲜的橘子，就返回0 */
        if(freshCount == 0) {
            return 0;
        }
        /**如果有新鲜的，没有不新鲜的，就不可能全部感染 */
        if(queue.isEmpty()) {
            return -1;
        }
        /**当前的分钟数*/
        int nowTime = 0;
        /**下面我们开始队列的弹出和一层层入队的过程，如果没有就返回-1*/
        while(!queue.isEmpty()) {
            int curLevelSize = queue.size();
            /**弹出当前层并把下一层感染加入队列*/
            for(int i = 0; i < curLevelSize; i++) {
                int[] pop = queue.poll();
                freshCount -= infect(grid, pop[0] - 1, pop[1],queue);
                freshCount -= infect(grid, pop[0], pop[1] + 1,queue);
                freshCount -= infect(grid, pop[0] + 1, pop[1],queue);
                freshCount -= infect(grid, pop[0], pop[1] - 1,queue);
            }
            /**我们的逻辑是加入完下一批就把nowTime++，因为我们将在nowTime时间把这些弹出，所以nowTime是加入下一批的时间
            如果下一批没有就不存在加入的问题，也就不用++了*/
            if(queue.isEmpty()) {
                break;
            }
            nowTime ++;
        }
        return freshCount != 0? - 1:nowTime;
    }
    /**感染下一层的方法：只感染它的上下左右,如果被感染成腐烂的了，加入队列
    返回感染了多少个 */
    public int infect(int[][] grid, int i, int j,Queue<int[]> queue) {
        if(i < 0 || i >= grid.length || j < 0 || j >= grid[i].length || grid[i][j] != 1) {
            return 0;
        }
        queue.offer(new int[]{i, j});
        grid[i][j] = 2;
        return 1;
    }
}