【Leetcode】994. Rotting Oranges

题目地址：

https://leetcode.com/problems/rotting-oranges/

给定一个int矩阵，$0$表示空格子，$1$表示是个新鲜的橘子，$2$表示是个腐烂的橘子。每过一分钟，腐烂的橘子会将其相邻的新鲜的橘子变腐烂。问最少经过多少分钟，整个矩阵里就没有新鲜的橘子了。如果最终确实没有新鲜橘子了，返回分钟数；否则返回$-1$。

思路是BFS，先将所有烂橘子的坐标入队，然后像BFS一个图一样遍历这个矩阵。每poll一个坐标出来，就将其四周的$1$变为$2$，并且将新的值为$2$的坐标入队，接下来再腐烂周围的橘子。每遍历一层，都要做一下标记，即当前层是否有新的新鲜橘子被感染，如果是，就将分钟数 + 1。由于还需要统计是否是所有的橘子都腐烂了，我们需要保存一个变量来存储当前有多少橘子是好的。最后返回时也要check一下是否有好的橘子剩下。代码如下：

import java.util.LinkedList;
import java.util.Queue;

public class Solution {
    public int orangesRotting(int[][] grid) {
    	// 判空
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return -1;
        }
        
        int m = grid.length, n = grid[0].length;
        // 存一下一共有多少个好橘子
        int good = 0;
        // BFS开一个队列来存下标
        Queue<int[]> queue = new LinkedList<>();
        // 将坏橘子坐标入队，同时统计好橘子个数
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 2) {
                    queue.offer(new int[]{i, j});
                } else if (grid[i][j] == 1) {
                    good++;
                }
            }
        }
        
        int[][] d = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
        int res = 0;
        while (!queue.isEmpty()) {
        	// 由于这里BFS需要分层，所以要存队列的大小
            int size = queue.size();
            for (int i = 0; i < size; i++) {
            	// 把本层腐烂的橘子出队
                int[] cur = queue.poll();
                // 分四个方向感染橘子
                for (int j = 0; j < 4; j++) {
                    int newX = cur[0] + d[j][0];
                    int newY = cur[1] + d[j][1];
                    // 如果走一步的位置合法，并且有个好橘子，就感染它，然后入队，并且标记好橘子数量 - 1
                    if (0 <= newX && newX < m && 0 <= newY && newY < n && grid[newX][newY] == 1) {
                        queue.offer(new int[]{newX, newY});
                        grid[newX][newY] = 2;
                        good--;
                    }
                }
            }
            // 如果本层遍历完后队列不空，说明本轮有新的橘子被感染，则统计分钟数 + 1；否则说明没有新的橘子感染，直接退出循环
            if (queue.size() != 0) {
                res++;
            } else {
            	break;
            }
        }
        // 如果好橘子都腐烂了，就返回分钟数；否则说明还剩下好橘子，返回-1
        return good == 0 ? res : -1;
    }    
}

时空复杂度$O(n)$。$n$为矩阵规模。

来源：CSDN

作者：edWard的算法世界

链接：https://blog.csdn.net/qq_46105170/article/details/104356358