广度优先搜索 LeetCode994. Rotting Oranges

最新推荐文章于 2024-05-13 09:39:59 发布

原创最新推荐文章于 2024-05-13 09:39:59 发布 · 750 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 同时被 2 个专栏收录

9 篇文章

订阅专栏

bfs

2 篇文章

订阅专栏

本文详细解析了LeetCode 994题“腐烂的橘子”算法题，通过使用广度优先搜索（BFS）策略，介绍了如何在二维网格中找到使所有新鲜橘子腐烂所需的最短时间。文章首先初始化队列，将所有腐烂橘子的位置及其腐烂时间加入队列，然后从这些腐烂橘子开始向外扩展，检查其上下左右的新鲜橘子并更新它们的状态和腐烂时间。最终，如果所有橘子都腐烂，则返回所需时间；否则，返回-1。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

LeetCode994. Rotting Oranges

用一个节点node保存橘子的坐标和腐烂的时间

初始化：将所有烂橘子加入队列，没有烂橘子返回-1

遍历，没有新鲜橘子返回0

从烂橘子的上下左右往外扩展，拓展时更新时间

遍历完成后如果还有新鲜橘子返回-1

struct node
    {
        int x,y;
        int t;
    };
class Solution {
public:
    
    int orangesRotting(vector<vector<int>>& grid) {
        int n = grid.size();
        int m = grid[0].size();
        queue<node> q;
        for(int i = 0; i < n; i++){
            for(int j = 0; j < m; j++){
                if(grid[i][j]==2){
                    node a;
                    a.x=i;
                    a.y=j;
                    a.t=0;
                    q.push(a);
                }
            }
        }
        int ans=0;
        int res=0;
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < m; j++)
            {
                if(grid[i][j]==1) res++;
            }
        }
        if(res==0) return 0;
        if(q.empty()) return -1;
        int time=0;
        while(!q.empty()){
            node tmp=q.front();
            time++;
            if(tmp.x-1>=0 && tmp.x-1<n){//up
                if(grid[tmp.x-1][tmp.y]==1) {
                    grid[tmp.x-1][tmp.y]=2;
                node tt;
                tt.x=tmp.x-1;
                tt.y=tmp.y;
                tt.t=tmp.t+1;
                ans=tmp.t+1;
                q.push(tt);
               // cout<<tt.x<<" "<<tt.y<<" "<<tt.t<<endl;
                }
                
            }
            if(tmp.x+1>=0 && tmp.x+1<n){//down
                if(grid[tmp.x+1][tmp.y]==1) {
                      grid[tmp.x+1][tmp.y]=2;
                node tt;
                tt.x=tmp.x+1;
                tt.y=tmp.y;
                tt.t=tmp.t+1;
                ans=tmp.t+1;
                q.push(tt);
                 //  cout<<tt.x<<" "<<tt.y<<" "<<tt.t<<endl;
                }
              
            }
            if(tmp.y-1>=0 && tmp.y-1<m){//left
                if(grid[tmp.x][tmp.y-1]==1) {
                       grid[tmp.x][tmp.y-1]=2;
                node tt;
                tt.x=tmp.x;
                tt.y=tmp.y-1;
                tt.t=tmp.t+1;
                ans=tmp.t+1;
                q.push(tt);
                  // cout<<tt.x<<" "<<tt.y<<" "<<tt.t<<endl;
                }
             
            }
            if(tmp.y+1>=0 && tmp.y+1<m){//righy
                if(grid[tmp.x][tmp.y+1]==1) {
                      grid[tmp.x][tmp.y+1]=2;
                node tt;
                tt.x=tmp.x;
                tt.y=tmp.y+1;
                tt.t=tmp.t+1;
                ans=tmp.t+1;
                q.push(tt);
                  // cout<<tt.x<<" "<<tt.y<<" "<<tt.t<<endl;
                }
              
            }
            q.pop();
            //if(time>=200) return -1;
        }
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < m; j++)
            {
                if(grid[i][j]==1) return -1;
            }
        }
        return ans;
    }
};