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

思路：我就是补丁狂人，疯狂打补丁然后就过了，害

dfs，直接从腐烂的橘子出发，遍历周围的4个方向如果是1就赋值为times，当然要特判一下是否超过边界，

而且因为是多源，所以可以check一下当前的times是否小于之前赋值，如果小就替换掉

然后再特判一下没有腐烂橘子，没有正常橘子的情况就好了

 1 class Solution {
 2 public:
 3     int vis[20][20];
 4     void dfs(vector<vector<int> >& grid,int i,int j, int x, int y, int times) {
 5         //vis[i][j] = 1;
 6         if((i + 1 >= 0 && i + 1 < x) && grid[i + 1][j] == 1 && (times < vis[i + 1][j] || vis[i + 1][j] == 0))
 7         {
 8             vis[i+1][j] = times;
 9             dfs(grid, i+1, j , x, y, times + 1);
10         }
11         if((i - 1 >= 0 && i - 1 < x) && grid[i - 1][j] == 1 && (times < vis[i - 1][j] || vis[i - 1][j] == 0))
12         {
13             vis[i - 1][j] = times;
14             dfs(grid, i - 1, j , x, y, times + 1);
15         }
16 
17         if((j - 1 >= 0 && j - 1 < y) && grid[i][j - 1] == 1 && (times < vis[i][j - 1] || vis[i][j-1] == 0))
18         {
19             vis[i][j - 1] = times;
20             dfs(grid, i, j - 1, x, y, times + 1);
21         }
22 
23         if((j + 1 >= 0 && j + 1 < y) && grid[i][j + 1] == 1 && (times < vis[i][j + 1] || vis[i][j+1] == 0))
24         {
25             vis[i][j + 1] = times;
26             dfs(grid, i, j + 1, x, y, times + 1);
27         }
28     }
29     int orangesRotting(vector<vector<int> >& grid) {
30         memset(vis,0,sizeof(vis));
31         int one =0,two =0;
32         for(int i = 0 ;i < grid.size();i++)
33         {
34             for(int j = 0; j < grid[0].size(); j ++)
35             {
36                 if(grid[i][j] == 1)
37                 {
38                     one++;
39                 }
40                 if(grid[i][j] == 0)
41                     vis[i][j] = -1;
42                 if(grid[i][j] == 2)
43                 {
44                     vis[i][j] = -2;
45                     two++;
46                     dfs(grid, i, j, grid.size(), grid[0].size(), 1);
47                 }
48             }
49         }
50         if(one ==0 && two != 0)
51             return 0;
52         if(one ==0 && two ==0)
53             return 0;
54         if(two == 0)
55             return -1;
56         int ans = -1,flag = -1, flag2 = -1;
57         for(int i = 0 ;i < grid.size();i++)
58         {
59             for(int j = 0; j < grid[0].size(); j ++)
60             {
61                 if(vis[i][j] > 0)
62                     flag2 = 1;
63                 if(vis[i][j] == 0 )
64                     flag = 1;
65                 if(vis[i][j] > ans)
66                     ans = vis[i][j];
67             }
68         }
69         if(flag2 != -1)
70             return flag == -1 ? ans : -1;
71         else {
72             if(two <0)
73                 return 0;
74             else return -1;
75         }
76     }
77 };
78 /*
79   2 1 1
80   0 1 1
81   1 0 1
82 
83   0 1
84   2 0
85 
86   2 1 1
87   1 1 0
88   0 1 1
89 */

View Code