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

值 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
12-23 20:37