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是否小于之前赋值，如果小就替换掉

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

class Solution {
public:
    int vis[20][20];
    void dfs(vector<vector<int> >& grid,int i,int j, int x, int y, int times) {
        //vis[i][j] = 1;
        if((i + 1 >= 0 && i + 1 < x) && grid[i + 1][j] == 1 && (times < vis[i + 1][j] || vis[i + 1][j] == 0))
        {
            vis[i+1][j] = times;
            dfs(grid, i+1, j , x, y, times + 1);
        }
        if((i - 1 >= 0 && i - 1 < x) && grid[i - 1][j] == 1 && (times < vis[i - 1][j] || vis[i - 1][j] == 0))
        {
            vis[i - 1][j] = times;
            dfs(grid, i - 1, j , x, y, times + 1);
        }

        if((j - 1 >= 0 && j - 1 < y) && grid[i][j - 1] == 1 && (times < vis[i][j - 1] || vis[i][j-1] == 0))
        {
            vis[i][j - 1] = times;
            dfs(grid, i, j - 1, x, y, times + 1);
        }

        if((j + 1 >= 0 && j + 1 < y) && grid[i][j + 1] == 1 && (times < vis[i][j + 1] || vis[i][j+1] == 0))
        {
            vis[i][j + 1] = times;
            dfs(grid, i, j + 1, x, y, times + 1);
        }
    }
    int orangesRotting(vector<vector<int> >& grid) {
        memset(vis,0,sizeof(vis));
        int one =0,two =0;
        for(int i = 0 ;i < grid.size();i++)
        {
            for(int j = 0; j < grid[0].size(); j ++)
            {
                if(grid[i][j] == 1)
                {
                    one++;
                }
                if(grid[i][j] == 0)
                    vis[i][j] = -1;
                if(grid[i][j] == 2)
                {
                    vis[i][j] = -2;
                    two++;
                    dfs(grid, i, j, grid.size(), grid[0].size(), 1);
                }
            }
        }
        if(one ==0 && two != 0)
            return 0;
        if(one ==0 && two ==0)
            return 0;
        if(two == 0)
            return -1;
        int ans = -1,flag = -1, flag2 = -1;
        for(int i = 0 ;i < grid.size();i++)
        {
            for(int j = 0; j < grid[0].size(); j ++)
            {
                if(vis[i][j] > 0)
                    flag2 = 1;
                if(vis[i][j] == 0 )
                    flag = 1;
                if(vis[i][j] > ans)
                    ans = vis[i][j];
            }
        }
        if(flag2 != -1)
            return flag == -1 ? ans : -1;
        else {
            if(two <0)
                return 0;
            else return -1;
        }
    }
};
/*
  2 1 1
  0 1 1
  1 0 1

  0 1
  2 0

  2 1 1
  1 1 0
  0 1 1
*/