题目：
在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。

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

C++：

//一般当一个对象有多个属性的时候，我们会用结构体stuct写多个属性，而当只有两个属性的时候，就可以使用pair.
//pair<int, int> P;        //对象P有两个属性，都是int类型

// 思路：bfs 广度优先搜索 首先将烂橘子坐标全放到队列中去。进而广度优先搜索，进行判定。可以看代码注释。


class Solution
{
public:
	int badorange(vector<vector<int>>& gride)
	{
		// bfs 广度优先，将腐烂橘子的坐标放到队列中
		int m = gride.size();
		int n = gride[0].size();
		queue<pair<int, int>>q; // 存放腐烂橘子的坐标
		bool flag = false;      // 记录是否有好橘子，若无则直接返回0
		int goodnums = 0;
		for (int i = 0; i < m; i++)
		{
			for (int j = 0; j < n; j++)
			{
				if (gride[i][j] == 2)
				{
					q.push({ i, j });
				}
				else if (gride[i][j] == 1)
				{
					flag = true;
					goodnums++;      // 好橘子的数量
				}
			}
		}
		if (!flag)  return 0;
		int time = 0;
		while (!q.empty())
		{
			int qLen = q.size();
			flag = false;   // 记录本回合是否有好橘子变烂，若无则可直接返回，时间不进行+1
			for (int i = 0; i < qLen; i++)
			{
				[x, y] = q.front();
				q.pop();
				// 判断腐烂橘子的上下左右是否有新鲜橘子
				if (x > 0 && gride[x - 1][y] == 1)
				{
					flag = true;
					gride[x - 1][y] = 2;	// 新鲜橘子变烂
					goodnums--;				// 新鲜橘子-1
					q.push({ x - 1, y });	// 新的烂橘子坐标
				}
				if (x < m - 1 && gride[x + 1][y] == 1)
				{
					flag = true;
					gride[x + 1][y] = 2;
					goodnums--;
					q.push({ x + 1, y });
				}
				if (y > 0 && gride[x][y - 1] == 1)
				{
					flage = true;
					gride[x][y - 1] = 2;
					goodnums--;
					q.push({ x, y - 1 });
				}
				if (y < n - 1 && gride[x][y - 1] == 1)
				{
					flage = true;
					gride[x][y - 1] = 2;
					goodnums--;
					q.push({ x, y - 1 });
				}
			}
			if (flag = true)
			{
				time++;
			}
			else
				break;	// 本回合无新鲜橘子变烂，直接返回
		}
		if (goodnums == 0)
		{
			return time;
		}
		else
			return -1;
	}
};

python:

思路：

# 1、先遍历一次数组获取腐烂橘子的位置，以及新鲜橘子的位置分别存在mold和fresh中
# 2、此时若没有mold且没有fresh则证明为空，返回0；若仅没有mold则证明永远不会腐烂，返回-1
# 3、接着遍历mold中的所有坐标，check他们的上下左右，如果在fresh中则该坐标需要从fresh中取出，并且加入mold。
# 4、一轮遍历完成让count++，如果mold此时为空则可以停止，mold中仍有坐标则循环3中的遍历
# 5、返回时检查fresh，如果fresh为空则说明所有橘子已经腐烂，返回count值即可，仍有fresh说明永远有橘子无法腐烂

class Solution:
    def orangesRotting(self, grid):
        maxi = len(grid)
        maxj = len(grid[0])
            
        count = -1
        mold = []
        tmp = []
        fresh = set()
        # 遍历grid获取新鲜橘子坐标fresh，腐烂坐标mold
        for i in range(maxi):
            for j in range(maxj):
                if grid[i][j] == 1:
                    fresh.add((i,j))
                elif grid[i][j] == 2:
                    mold.append([i,j])
        # 此时若没有mold且没有fresh则证明为空，返回0；若仅没有mold则证明永远不会腐烂，返回-1
        if not mold and not fresh: return 0
        if not mold: return -1

        # 腐烂橘子的函数
        def check(i, j):
            if (i,j) in fresh:
                fresh.remove((i,j))
                tmp.append((i,j))
        
        # 每轮循环检查mold中坐标的上下左右是否可以腐烂
        while mold != []:
            for x in mold:
                check(x[0]-1,x[1])
                check(x[0]+1,x[1])
                check(x[0],x[1]-1)
                check(x[0],x[1]+1)
            mold = tmp
            tmp = []
            count += 1
        
        # 如果fresh为空则说明所有橘子已经腐烂，返回count值即可，仍有fresh说明永远有橘子无法腐烂
        if len(fresh) == 0:
            return count
        else: return -1