LeetCode 1129.颜色交替的最短路径

题目描述

在一个有向图中，节点分别标记为 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。

题目分析

进阶版BFS，需要考虑的颜色状态，每一次更改颜色状态，总步数加1。并且对要记录的visit路径进行颜色区分。使用最小的step去更新当前位置的ans值。

C++代码

struct node {
    int x;
    int y;
};
class Solution {
public:
    vector shortestAlternatingPaths(int n, vector>& red_edges, vector>& blue_edges) {
        vector ans(n, -1);
        int visit[105][105][2];
        memset(visit, 0, sizeof(visit));
        vector >> colMap(2);
        for(int i = 0; i < red_edges.size(); i++) {
            colMap[0][red_edges[i][0]].push_back(red_edges[i][1]);
        }
        for(int i = 0; i < blue_edges.size(); i++) {
            colMap[1][blue_edges[i][0]].push_back(blue_edges[i][1]);
        }
        
        queue que;
        node rnode;
        rnode.x = 0;
        rnode.y = 0;
        node bnode;
        bnode.x = 0;
        bnode.y = 1;
        que.push(rnode);
        que.push(bnode);
        int step = 0;
        while(!que.empty()) {
            step++;
            int sz = que.size();
            for(int s = 0; s < sz; s++) {
                int cur = que.front().x;
                int col = (que.front().y + 1)%2;
                que.pop();
                for(int i = 0; i < colMap[(col + 1)%2][cur].size(); i++) {
                    int ns = colMap[(col + 1)%2][cur][i];
                    if(visit[cur][ns][col] == 0) {
                       if(ans[ns] == -1) ans[ns] = step;
                       else {
                           ans[ns] = min(ans[ns], step);
                       }
                       visit[cur][ns][col] = 1;
                       node next;
                       next.x = ns;
                       next.y = col;
                       que.push(next);
                    } 
                }
            }
        }
        ans[0] = 0;
        return ans;
    }
};