leetcode------Rotting Oranges

最新推荐文章于 2024-12-15 12:30:04 发布

原创最新推荐文章于 2024-12-15 12:30:04 发布 · 157 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode

leetcode 专栏收录该内容

100 篇文章

订阅专栏

博主在项目中使用广度搜索找连通域，发现代码运行超时，认为代码质量不佳，需要改进，同时表示未透彻理解题目意思，并记录此事。

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

class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) {
        int fresh=0;
        int dTime=0;
        for(int i=0;i<grid.size();++i)
        {
            for(int j=0;j<grid[i].size();++j)
            {
                int orange=grid[i][j];
                stack<pair<int,int>> adjacent;
                if(orange==2)
                {
                    adjacent.push(pair<int,int>(1,1));
                    while(!adjacent.empty())
                    {
                        pair<int,int> V=adjacent.top();
                        adjacent.pop();
                         int old_size=adjacent.size();
                        if(V.first-1>=0) 
                        {
                             if(grid[V.first-1][V.second]==1)   adjacent.push(pair<int,int>(V.first-1,V.second));
                        }
                        if(V.first+1<grid.size()) 
                        {
                             if(grid[V.first+1][V.second]==1)   adjacent.push(pair<int,int>(V.first+1,V.second));
                        }
                        if(V.second-1>=0) 
                        {
                             if(grid[V.first][V.second-1]==1)   adjacent.push(pair<int,int>(V.first,V.second-1));
                        }
                        if(V.second+1<grid[V.first].size()) 
                        {
                             if(grid[V.first][V.second+1]==1)   adjacent.push(pair<int,int>(V.first,V.second+1));
                        }
                        if(adjacent.size()>old_size)    dTime++;
                       
                    }
                }
                else  if(orange==1)
                {
                        if(i-1>=0) 
                        {
                             if(grid[i-1][j]==0)   ++fresh;
                        }
                        else {++fresh;}
                        if(i+1<grid.size()) 
                        {
                             if(grid[i+1][j]==0)   ++fresh;
                        }
                        else {++fresh;}
                        if(j-1>=0) 
                        {
                             if(grid[i][j]==0)   ++fresh;
                        }
                        else {++fresh;}
                        if(j+1<grid[i].size()) 
                        {
                             if(grid[i][j]==0)   ++fresh;
                        }
                        else {++fresh;}
                    if(fresh==4)    return -1;
                }
                
            }
        }
        
       return dTime; 
    }
};

项目中我就是这么广度搜索找的连通域，但是这里显然时间超过了，显然这代码写得很垃圾！所以得改进；以此记录！

题目意思也没理解透彻：

class Solution {
public:
    void PUSH(int i,int j,std::queue<pair<int,int>> & q,vector<vector<int>>& grid,int &fresh)
    {
             if(i>=0 &&i<grid.size()&&j>=0&&j<grid[i].size() &&grid[i][j]==1) 
             {
                 grid[i][j]=2;
                 fresh--;
                 q.push(pair<int,int>(i,j));
             }
    }
    int orangesRotting(vector<vector<int>>& grid) {
        int fresh=0;
        int dTime=0;
        int row=0;
        int col=0;
        std::queue<pair<int,int>> adjacent;
        for(vector<vector<int>>::iterator iter=grid.begin();iter!=grid.end();++iter)
        {
            col=0;
            for(vector<int>::iterator ivter=grid[row].begin();ivter!=grid[row].end();++ivter)
            {
                int value=*ivter;
                if(value==2)   adjacent.push(pair<int,int>(row,col));
                else if(value==1)  fresh++;
                col++;
            }
            row++;
        }
          while(fresh!=0)
         {
              if(adjacent.size()==0)        return -1;
                        int size=adjacent.size();
                        for(int i=0;i<size;++i)
                        {
                             pair<int,int> V=adjacent.front();
                             adjacent.pop();
                             PUSH(V.first-1,V.second,adjacent,grid,fresh);
                            PUSH(V.first,V.second+1,adjacent,grid,fresh);
                            PUSH(V.first+1,V.second,adjacent,grid,fresh);
                            PUSH(V.first,V.second-1,adjacent,grid,fresh);
                        }
                        if(adjacent.size()>0)    ++dTime;
                       
                    
        }
               
        
       return dTime; 
    }
};