双队列交叉应用

问题描述

在一个有向图中，节点分别标记为 0, 1, …, n-1。这个图中的每条边不是红色就是蓝色，且存在自环或平行边。

red_edges 中的每一个 [i, j] 对表示从节点 i 到节点 j 的红色有向边。类似地，blue_edges 中的每一个 [i,
j] 对表示从节点 i 到节点 j 的蓝色有向边。

返回长度为 n 的数组 answer，其中 answer[X] 是从节点 0 到节点 X
的最短路径的长度，且路径上红色边和蓝色边交替出现。如果不存在这样的路径，那么 answer[x] = -1。

示例 1：

输入：n = 3, red_edges = [[0,1],[1,2]], blue_edges = [] 输出：[0,1,-1] 示例 2：

输入：n = 3, red_edges = [[0,1]], blue_edges = [[2,1]] 输出：[0,1,-1] 示例 3：

输入：n = 3, red_edges = [[1,0]], blue_edges = [[2,1]] 输出：[0,-1,-1] 示例 4：

输入：n = 3, red_edges = [[0,1]], blue_edges = [[1,2]] 输出：[0,1,2] 示例 5：

输入：n = 3, red_edges = [[0,1],[0,2]], blue_edges = [[1,0]] 输出：[0,1,1]

提示：

1 <= n <= 100 red_edges.length <= 400 blue_edges.length <= 400
red_edges[i].length == blue_edges[i].length == 2 0 <= red_edges[i][j],
blue_edges[i][j] < n

参考源码

const int INF = 1000000000;

class Solution {
public:
    using pii = pair<int, int>;
    vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& red_edges, vector<vector<int>>& blue_edges) {
        int d[n][2];
        for (int i = 0; i < n; ++ i)
            d[i][0] = d[i][1] = INF;
        d[0][0] = d[0][1] = 0;
        
        vector<int> v[n][2];
        for (auto e : red_edges)
            v[e[0]][0].push_back(e[1]);
        for (auto e : blue_edges)
            v[e[0]][1].push_back(e[1]);
        
        queue<pii> Q;
        Q.push(pii(0, 0));
        Q.push(pii(0, 1));
        while (!Q.empty())
        {
            int x, k;
            tie(x, k) = Q.front();
            Q.pop();
            for (auto y : v[x][k])
            {
                if (d[y][k^1] > d[x][k]+1)
                {
                    d[y][k^1] = d[x][k]+1;
                    Q.push(pii(y, k^1));
                }
            }
        }
        
        vector<int> ret(n);
        for (int i = 0; i < n; ++ i)
        {
            ret[i] = min(d[i][0], d[i][1]);
            if (ret[i] == INF) ret[i] = -1;
        }
        return ret;
    }
};

转自https://leetcode-cn.com/u/liouzhou_101