(LeetCode 热题 100) 994. 腐烂的橘子（广度优先搜索bfs、队列）

题目：994. 腐烂的橘子

思路：广度优先搜索bfs，用队列保存腐烂的橘子，用数组sta来标记已经遍历过的地方。

C++版本：

class Solution {
public:
    typedef pair<int,int> PII;
    int n,m;
    vector<vector<bool>> sta;
    int fx[4]={0,0,1,-1};
    int fy[4]={1,-1,0,0};
    int bfs(vector<vector<int>>& grid){
        queue<PII> qu;
        //记录好的橘子数
        int ans=0;
        //队列保存腐烂的橘子
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(grid[i][j]==2){
                    qu.push({i,j});
                    sta[i][j]=1;//标记已遍历过
                }else if(grid[i][j]==1){
                    ans++;//记录好的橘子数
                }
            }
        }
        if(ans==0) return 0;
        //times记录时间，-1是因为一开始腐烂的橘子不要时间
        int times=-1;
        while(qu.size()){
        	//记录当前腐烂的橘子数
            int cnt=qu.size();
            times++;
            while(cnt--){
                PII tmp=qu.front();
                qu.pop();
                for(int i=0;i<4;i++){
                    int x=tmp.first + fx[i];
                    int y=tmp.second + fy[i];
                    if(x<0||x>=n||y<0||y>=m) continue;
                    if(sta[x][y]!=0 || grid[x][y]!=1) continue;
                    ans--;
                    qu.push({x,y});
                    sta[x][y]=1;
                }
            }
        }
        if(ans!=0) return -1;
        return times;  
    }
    int orangesRotting(vector<vector<int>>& grid) {
        n=grid.size();
        m=grid[0].size();
        //标记数组
        sta.assign(n,vector<bool>(m,0));
        return bfs(grid);
    }
};

优化标记数组，直接在grid上进行修改，将遍历过的位置，grid值置为1。

class Solution {
public:
    typedef pair<int,int> PII;
    int n,m;
    int fx[4]={0,0,1,-1};
    int fy[4]={1,-1,0,0};
    int bfs(vector<vector<int>>& grid){
        queue<PII> qu;
        int ans=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(grid[i][j]==2){
                    qu.push({i,j});
                    grid[i][j]=0;
                }else if(grid[i][j]==1){
                    ans++;
                }
            }
        }
        if(ans==0) return 0;
        int times=-1;
        while(qu.size()){
            int cnt=qu.size();
            times++;
            while(cnt--){
                PII tmp=qu.front();
                qu.pop();
                for(int i=0;i<4;i++){
                    int x=tmp.first + fx[i];
                    int y=tmp.second + fy[i];
                    if(x<0||x>=n||y<0||y>=m) continue;
                    if(grid[x][y]!=1) continue;
                    ans--;
                    qu.push({x,y});
                    grid[x][y]=0;
                }
            }
        }
        if(ans!=0) return -1;
        return times;  
    }
    int orangesRotting(vector<vector<int>>& grid) {
        n=grid.size();
        m=grid[0].size();
        return bfs(grid);
    }
};

JAVA版本：

class Solution {
    int n,m;
    int[] fx={0,0,1,-1};
    int[] fy={1,-1,0,0};
    int bfs(int[][] grid){
        Queue<int[]> qu = new LinkedList<>();
        int ans=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(grid[i][j]==2){
                    qu.add(new int[]{i,j});
                    grid[i][j]=0;
                }else if(grid[i][j]==1){
                    ans++;
                }
            }
        }
        if(ans==0) return 0;
        int times=-1;
        while(!qu.isEmpty()){
            int cnt=qu.size();
            times++;
            while(cnt!=0){
                cnt--;
                int[] tmp=qu.poll();
                for(int i=0;i<4;i++){
                    int x=tmp[0] + fx[i];
                    int y=tmp[1] + fy[i];
                    if(x<0||x>=n||y<0||y>=m) continue;
                    if(grid[x][y]!=1) continue;
                    ans--;
                    qu.add(new int[]{x,y});
                    grid[x][y]=0;
                }
            }
        }
        if(ans!=0) return -1;
        return times;  
    }
    public int orangesRotting(int[][] grid) {
        n=grid.length;
        m=grid[0].length;
        return bfs(grid);
    }
}