LeetCode-994. 腐烂的橘子

题目：

在给定的网格中，每个单元格可以有以下三个值之一：

值0代表空单元格；
值1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。
返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1。

示例：

示例 1：

输入：[[2,1,1],[1,1,0],[0,1,1]]
输出：4

示例 2：

输入：[[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个正向上。

示例 3：

输入：[[0,2]]
输出：0
解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。

提示：

• 1 <= grid.length <= 10
• 1 <= grid[0].length <= 10
• grid[i][j]仅为 0、1 或 2

解题思路：

典型的BFS解法的题目，
1. 先找到起始所有腐烂的橘子，
2. 然后循环处理，把新腐烂的橘子加入下一次循环的队列中， 当下一次循环的队列为空时，说明 不能继续腐烂了
3. 最后判断一下还有没有新鲜的橘子，如果有，就返回-1，否则返回分钟数

代码实现：

class Solution {

   int[][] direction = new int[][] { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };
   public int orangesRotting(int[][] grid) {
       int rows = grid.length;
       int cols = grid[0].length;
       int count = 0;
       Queue<int[]> queue = new LinkedList<>();
       for (int i = 0; i < rows; i++) {
           for (int j = 0; j < cols; j++) {
               if (grid[i][j] == 1) {
                   count++;//统计新鲜橘子数
               }
               if (grid[i][j] == 2) {
                   queue.add(new int[] { i, j });
               }
           }
       }
       int minute = 0;
       while (count > 0 && !queue.isEmpty()) {
           minute++;
           int n = queue.size();//当前层腐烂橘子数量， 因为每层在更新队列
           for (int i = 0; i < n; i++) {
               int[] decomposed = queue.poll();//腐烂的橘子出队
               int row = decomposed[0];
               int col = decomposed[1];
               for (int k = 0; k < 4; k++) {
                   int x = row + direction[k][0];
                   int y = col + direction[k][1];
                   if (x >= 0 && x < rows && y >= 0 && y < cols && grid[x][y] == 1) {
                       grid[x][y] = 2;
                       count--;
                       queue.add(new int[] { x, y });//腐烂的橘子入队
                   }
               }
           }
       }
       //还有健康的橘子返回 -1,否则,返回时间
       return count > 0 ? -1 : minute;
   }
}

复杂度分析：

• 时间复杂度： $O(nm)$
  即进行一次广度优先搜索的时间，其中 $n=grid.length$, $m=grid[0].length$ 。

• 空间复杂度： $O(nm)$
  需要额外的count记录新鲜的橘子，最大为 $O(nm)$，且广度优先搜索中队列里存放的状态最多不会超过 $nm$个，最多需要 $O(nm)$ 的空间，所以最后的空间复杂度为 $O(nm)$。