leetcode 994. 腐烂的橘子（C++、python）

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

• 值 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

思路：首先，将腐烂橘子的坐标放在一个容器中；对这个容器中的每个元素，判断其四周是否有好的橘子，如果有，则将好的橘子的坐标加入新的容器中；对新的容器重复同样的操作，直到腐烂橘子的周围没有好的橘子。

C++

class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) 
    {
        int m=grid.size();
        int n=grid[0].size();
        vector<pair<int,int>> tmp;
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(2==grid[i][j])
                {
                    tmp.push_back(make_pair(i,j));
                }
            }
        }
        int count=0;
        while(tmp.size())
        {
            vector<pair<int,int>> vec;
            int len=tmp.size();
            for(int i=0;i<len;i++)
            {
                auto it=tmp[i];
                int x=it.second;
                int y=it.first;
                if(x-1>=0 && 1==grid[y][x-1])
                {
                    grid[y][x-1]=2;
                    vec.push_back(make_pair(y,x-1));
                }
                if(x+1<n && 1==grid[y][x+1])
                {
                    grid[y][x+1]=2;
                    vec.push_back(make_pair(y,x+1));
                }   
                if(y-1>=0 && 1==grid[y-1][x])
                {
                    grid[y-1][x]=2;
                    vec.push_back(make_pair(y-1,x));
                }   
                if(y+1<m && 1==grid[y+1][x])
                {
                    grid[y+1][x]=2;
                    vec.push_back(make_pair(y+1,x));
                }            
            }
            if(vec.size())
            {
                count++;
            }
            tmp=vec;
        }
        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(1==grid[i][j])
                {
                    return -1;
                }
            }
        }
        return count;
    }
};

python

class Solution:
	def orangesRotting(self, grid: List[List[int]]) -> int:
		m=len(grid)
		n=len(grid[0])
		tmp=[]
		for i in range(m):
			for j in range(n):
				if 2==grid[i][j]:
					tmp.append([i,j])
		ort=[[0,-1],[0,1],[1,0],[-1,0]]
		res=0
		while len(tmp):
			vec=[]
			for it in tmp:
				for ss in ort:
					x=it[1]+ss[1]
					y=it[0]+ss[0]
					if x<n and x>=0 and y<m and y>=0 and 1==grid[y][x]:
						grid[y][x]=2
						vec.append([y,x])
			if len(vec):
				res+=1
			tmp=vec
		for i in range(m):
			for j in range(n):
				if 1==grid[i][j]:
					return -1
		return res