C++实现leetcode 994. 腐烂的橘子

1，leetcode 994

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

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。

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

• 先找出腐烂的橘子，添加进 queue 中。

• 队列 queue 只让腐烂的橘子入队；

• 出队时，让当前腐烂橘子四周的新鲜橘子都变为腐烂，即 grid[newX][newY] = 2。

• 用 minute 记录腐烂的持续时间，每一层的橘子在内一层的橘子的腐烂时间基础之上自增 1，代表时间过了 1 分钟。

• 最后检查网格中是否还有新鲜的橘子：

• 有，返回 -1 代表 impossible。

• 没有则返回 minute。

//方向数组：左上右下
int dx[]={0,-1,0,1},dy[]={-1,0,1,0};

class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) {
        int m=grid.size(),n=grid[0].size();
        int res=0;
        queue<pair<int,int>> q;
        //1、初始化队列：添加烂橘子
        for(int i=0;i<m;++i)
           for(int j=0;j<n;++j)
             {
                 if(grid[i][j]==2) 
                 q.push({i,j});
             }  
       //2、进行bfs：将每层橘子中四个方向的好橘子感染成烂橘子，并添加到队列中
        while(!q.empty()){
            int span=q.size();
            for(int i=0;i<span;++i){
                pair<int,int> p=q.front();//获取对头元素
                q.pop();//弹出队头
                for(int j=0;j<4;++j){//将每个烂橘子的4个方向的好橘子感染成烂橘子
                    int x=p.first+dx[j],y=p.second+dy[j];
                    if( x>=0 && x<m && y>=0 && y<n && grid[x][y]==1){
                        grid[x][y]=2;
                        q.push({x,y});//队尾添加元素 
                    }
                }
            }
            if(!q.empty())res++;//感染完一圈的橘子，res+1
        }
        for(int i=0;i<m;++i)for(int j=0;j<n;++j)if(grid[i][j]==1)return -1;
        return res;
    }

2，BFS

该算法用到了BFS广度优先搜索

如图所示，BFS为是从根节点开始，沿着树的宽度遍历树的节点。如果所有节点均被访问，则算法中止。如上图所示的二叉树，A 是第一个访问的，然后顺序是 B、C，然后再是 D、E、F、G。

2.1. 基本思路

仔细看看层序遍历过程，其实就是从上到下，从左到右依次将每个数放入到队列中，然后按顺序依次打印就是想要的结果。所以这里我们借助一个队列进行操作。

实现过程

首先将二叉树的根节点push到队列中，判断队列不为nullptr，就输出队头的元素，
判断节点如果有孩子，就将孩子push到队列中，
遍历过的节点出队列，
循环以上操作，直到Node == nullptr。

2.2，实现

#include <iostream>
#include <queue>
using namespace std;

struct Node
{
	int value;
	Node *left;
	Node *right;
	Node(int value) :value(value), left(NULL), right(NULL){}
};

void bfs(Node *head)
{
	if (head == NULL)
	{
		return;
	}
	queue<Node*> qbfs;
	qbfs.push(head);
	while (!qbfs.empty())
	{
		cout << qbfs.front()->value << ",";
		if (qbfs.front()->left != NULL)
		{
			qbfs.push(qbfs.front()->left);
		}
		if (qbfs.front()->right != NULL)
		{
			qbfs.push(qbfs.front()->right);
		}
		qbfs.pop();

	}
	cout << endl;
}

int main() {
	Node* head = new Node(1);
	head->left = new Node(2);
	head->right = new Node(3);
	head->left->left = new Node(4);
	head->left->right = new Node(5);
	head->right->left = new Node(6);
	head->right->right = new Node(7);

	std::cout << "\n==============BFS==============\n";
	bfs(head);
	system("pause");
	return 0;
}