题目链接

题目描述：

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

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。

返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1。

实例：
994腐烂的橘子 - 图1

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

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

解题思路

  题目要求返回直到单元格中没有新鲜橘子为止所必须经过的最小分钟数，实际就是求出腐烂橘子到所有新鲜橘子的最短路径。也就是说要用到队列实现BFS(广度优先搜索)。为了区分不同时间进入队列的腐烂橘子，在每一轮遍历开始前记录队列长度。按这个长度，根据队列特点，遍历循环长度之内的元素。

  1. 初始轮将所有腐烂的橘子放入队列中，记录新鲜橘子个数(可能有腐烂橘子污染不到的新鲜橘子)
  2. 进行BFS，将队首腐烂橘子出队并获取它的位置。对每个腐烂橘子的上下左右进行判断。若为新鲜橘子，就污染，同时减少新鲜橘子个数；否则，无作为。
  3. 某一轮遍历结束后，队列为空或新鲜橘子个数为0，则说明遍历结束。若存在未被污染的新鲜橘子，则返回-1；否则，说明污染成功，返回时间。

代码

  1. struct Point{
  2.     int x;  //行
  3.     int y;  //列
  4. };
  6. class Solution {
  7. public:
  8.     int orangesRotting(vector<vector<int>>& grid) {
  9.         queue<Point> queue_Grid;
  10.         int M = grid.size();            //获取行数
  11.         int N = grid[0].size();         //获取列数
  12.         int fresh_num = 0;              //新鲜水果数量
  14.         //第一轮(初始化) 遍历数组
  15.         for(int i = 0; i < M; i++){
  16.             for(int j = 0; j < N; j++){
  17.                 if(grid[i][j] == 2)     //检测为腐烂水果，入队
  18.                     queue_Grid.push(Point{i,j});
  19.                 else if(grid[i][j] == 1) //检测为新鲜水果，记录数量
  20.                     fresh_num++;
  21.             }
  22.         }
  24.         //1.一轮遍历队列中所有腐烂的水果；
  25.         //2.判断腐烂水果的四个方向，将他们变腐烂
  26.         //3.下一轮待遍历的腐烂水果进队
  27.         //直到某一轮过后无新鲜水果或队列为空(无腐烂水果进队)=》循环结束
  28.         int round = 0;                   //轮数or分钟数
  29.         while(fresh_num > 0 && !queue_Grid.empty()){
  30.             round++;
  31.             int n = queue_Grid.size(); //获取每一轮的队列长度
  32.             for(int i = 0; i < n; i++){
  33.                 Point temp = queue_Grid.front();
  34.                 queue_Grid.pop();
  35.                 int r = temp.x, c = temp.y;   //获取腐烂苹果的位置，行r列c
  36.                 if(r - 1 >= 0 && grid[r-1][c] == 1){ //上
  37.                     fresh_num--;
  38.                     grid[r-1][c] = 2;
  39.                     queue_Grid.push(Point{r-1,c});
  40.                 }
  41.                 if(r + 1 < M && grid[r+1][c] == 1){  //下
  42.                     fresh_num--;
  43.                     grid[r+1][c] = 2;
  44.                     queue_Grid.push(Point{r+1,c});
  45.                 }
  46.                 if(c - 1 >= 0 && grid[r][c-1] == 1){  //左
  47.                     fresh_num--;
  48.                     grid[r][c-1] = 2;
  49.                     queue_Grid.push(Point{r,c-1});
  50.                 }
  51.                 if(c + 1 < N && grid[r][c+1] == 1){  //右
  52.                     fresh_num--;
  53.                     grid[r][c+1] = 2;
  54.                     queue_Grid.push(Point{r,c+1});
  55.                 }
  56.             }
  57.         }
  59.         if(fresh_num > 0)
  60.             return -1;
  61.         else
  62.             return round;
  63.     }
  64. };

如果有错误或者不严谨的地方，请务必给予指正，十分感谢。