[宽度优先搜索] leetcode 1129 Shortest Path with Alternating Colors

problem:https://leetcode.com/problems/shortest-path-with-alternating-colors/

        周赛题，这道题是带约束的最短路径，我的做法是对不同颜色节点维护两个容器，分别计算从红色结点开始和从蓝色结点开始，取其中最小的。（这道题没有必要用优先队列的，因为是无权的，但是比赛时不知道咋想的）

class Solution {
public:
    unordered_map<int,unordered_set<int>> red;
    unordered_map<int,unordered_set<int>> blue;
    vector<int> dist_blue;
    vector<int> dist_red;
    int N;
    void bfs(bool bRed)
    {
        priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> red_q;
        priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>>> blue_q;
        vector<bool> visit_red(N, false); // 从红色到cur
        vector<bool> visit_blue(N, false); // 从蓝色到cur
        if(bRed)
            blue_q.push({0, 0});
        else 
            red_q.push({0, 0});
        while(true)
        {
            int size;
            if(bRed) size = blue_q.size();
            else size = red_q.size();
            if(size == 0) break;
            while(size--)
            {

                if(bRed) // 上一步是蓝色，这一步选红色
                {

                    int cur = blue_q.top().second;
                    visit_blue[cur] = true;
                    blue_q.pop();
                    for(auto& next : red[cur])
                    {
                        if(!visit_red[next])
                        {
                            red_q.push({dist_red[next], next});
                        }
                        dist_red[next] = min(dist_red[next], dist_blue[cur] + 1);

                    }
                }
                else // 上一步是红色，这一步选蓝色
                {
                    int cur = red_q.top().second;
                    visit_red[cur] = true;
                    red_q.pop();
                    for(auto& next : blue[cur])
                    {
                        if(!visit_blue[next])
                        {
                            blue_q.push({dist_blue[next], next});
                        }
                        dist_blue[next] = min(dist_blue[next], dist_red[cur] + 1);
                    }
                }
            }
            bRed = !bRed;
        }
     //   cout << endl;
    }
    vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& red_edges, vector<vector<int>>& blue_edges) {
        N = n;
        for(int i = 0;i < red_edges.size();i++)
        {
            red[red_edges[i][0]].insert(red_edges[i][1]);
        }
        for(int i = 0;i < blue_edges.size();i++)
        {
            blue[blue_edges[i][0]].insert(blue_edges[i][1]);
        }
        dist_blue.resize(n,INT_MAX);
        dist_red.resize(n,INT_MAX);
        dist_red[0] = 0;
        dist_blue[0] = 0;
        bfs(true);
        bfs(false);
        vector<int> res(n);
        for(int i = 0;i < n;i++)
        {
            res[i] = min(dist_blue[i], dist_red[i]);
            if(res[i] == INT_MAX) res[i] = -1;
        }
        return res;
  
    }
};