LeetCode 1129. 颜色交替的最短路径--进行路径标记后BFS

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。

示例 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

题解：

感觉就是处理路径比较麻烦，传统的图论题都是直接vis[u]标记点防止陷入死循环，但是这个又不仅仅是点的问题，因为两个点有多种路径，红路和绿路，一开始我用vis[u][v][c]标记路径，表示节点u到节点v走的哪条颜色的路径，但是这样也不对，因为有这样的情况，就是比如u的上级节点pre_u，如果节点pre_u到u也是有红绿两条路径，那么如果pre_u走红路到u，u再到v，就会把vis[u][v][0]和vis[u][v][1]都给标记，那么等pre_u走绿路到u，导致的结果就是u不能再走到v了，因为路径被提前标记了，于是考虑到这个问题，我们拓展维度，有了vis[u][cu][v][cv]；表示pre_u走的哪条路径到的u，u再走哪条路径到v，因为题目仅仅限制于两个相邻路径必须是颜色交替的，于是我们拓展到这个维度就行了。

AC代码

class Solution {
public:
    int color[110][110];
    int res[110];
    struct Node
    {
        int v,c;
    };
    vector<Node>to[110];
    queue<int>q;
    bool vis[110][3][110][3];
    void bfs()
    {
        memset(vis,0,sizeof(vis));
        memset(res,-1,sizeof(res));
        q.push(0);//装入节点
        q.push(2);//装入当前颜色标记，-1表示初始化
        q.push(0);//装入当前距离长度
        while(!q.empty())
        {
            int u=q.front();//取出节点
            q.pop();
            int cu=q.front();//取出颜色
            q.pop();
            int len=q.front();//取出长度
            q.pop();
            if(res[u]==-1)
            res[u]=len;//标记答案
            for(int i=0;i<to[u].size();i++)
            {
                int v=to[u][i].v;
                int cv=to[u][i].c;
                if(vis[u][cu][v][cv])continue;
                vis[u][cu][v][cv]=true;
                //cout<<u<<"->"<<v<<" color="<<cv<<endl;
                if(cu==2||!cu==cv)
                {
                 //   cout<<"***"<<u<<"->"<<v<<" color="<<cv<<endl;
                    q.push(v);
                    q.push(cv);
                    q.push(len+1);
                }
            }
        }
    }
    vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& red_edges, vector<vector<int>>& blue_edges) {
        for(int i=0;i<red_edges.size();i++)
        {
            int u=red_edges[i][0];
            int v=red_edges[i][1];
            Node t;
            t.v=v,t.c=1;
            to[u].push_back(t);
        }
        for(int i=0;i<blue_edges.size();i++)
        {
            int u=blue_edges[i][0];
            int v=blue_edges[i][1];
            Node t;
            t.v=v,t.c=0;
            to[u].push_back(t);
        }
        bfs();
        vector<int>pu;
        for(int i=0;i<n;i++)
        pu.push_back(res[i]);
        return pu;
    }
};