广度优先

广度优先模板

• 找广度优先的源点
  也就是队列的第一层
• 判断是否需要visited矩阵
  visited矩阵是用来防止无限循环的。腐烂的橘子的情况下，只有没有腐烂的橘子才能加入队列，所以可以不用visited。
• 判断是否要进行层次区分，
  腐烂的橘子需要判断每一层是否结束，来加时间。所以需要进行层次区分。while循环内部还需要加一个当前层次的判断。
• 遍历每一个源点的四个方向，看能否作为下一个源点
  能够的进行的入队，不能直接跳过

994 腐烂的橘子

class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) {
        queue<pair<int, int>> q{};
        int r = grid.size();
        int c = grid[0].size();
        int orange{0};
        for(int i{0}; i < r; ++i) // 判断源点
        {
            for(int j{0}; j < c; ++j)
            {
                if(grid[i][j] == 2) q.emplace(i, j);
                else if(grid[i][j] == 1) ++orange;   // 搞个orange 统计当前好的橘子数量；
            }
        }
        if(orange == 0 && q.empty()) return 0; // 好橘子，坏橘子都没有
        
        int ans{-1};
        int dirs[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
        while(!q.empty())
        {
            int s = q.size();
            while(s > 0) // 层次区分
            {
                auto p = q.front();
                q.pop();
                --s;
                for(auto dir: dirs) // 遍历四个方向
                {
                    int nextR = p.first + dir[0];
                    int nextC = p.second + dir[1];
                    if(nextR >=0 && nextR < r && nextC >= 0 && nextC < c && grid[nextR][nextC] == 1)
                    {
                        grid[nextR][nextC] = 2; // 求求了，不要再写双等号了
                        q.emplace(nextR, nextC);
                        --orange;
                    }
                }
            }
            ++ans;
        }
        if(orange > 0) return -1;
        else return ans;
    }
};