SGU 103 Traffic Lights（SPFA）

Description
给定一个带权无向图，每个点有一个颜色属性（B or P)，颜色会在B和P之间来回变换，两种颜色各有一个持续时间，两个邻接的点之间能够通行当且仅当两点是相同的颜色，通行的代价为边权，可在点处等待，给定起点，终点，每个点的初始颜色和持续时间，蓝色的持续时间，紫色的持续时间，求起点到终点的最短时间和满足最短时间的路径
Input
第一行两个整数s和t表示起点和终点，第二行两个整数n和m分别表示点数和边数，之后n行每行表示一个点的属性，首先是颜色(B or P)，然后是该点当前颜色的持续时间r，之后两个整数tb和tp表示该点蓝色和紫色的持续时间，最后m行每行表示一条边的属性，三个整数u,v,c表示u和v之间有一条权值为c的边
Output
输出起点到终点的最短时间和满足最短时间的路径
Sample Input
1 4
4 5
B 2 16 99
P 6 32 13
P 2 87 4
P 38 96 49
1 2 4
1 3 40
2 3 75
2 4 76
3 4 77
Sample Output
127
1 2 4
Solution
有限制条件的最短路，松弛条件为dis[v]>dis[u]+cost[u][v]+wait(u,v,dis[u])，其中dis[i]表示起点到i点的最短路，cost[i][j]表示i与j间的边权，wait(u,v,dis[u])表示在dis[u]时刻到达u时，从u到v的等待时间，难点在于wait的求法
用color(x,time,cx,tx)求出x在time时刻的颜色为cx且cx的持续时间到tx，下面看怎么求wait(u,v,time)
首先求出color(u,time,cu,tu)和color(v,time,cv,tv)
1.如果cv=cu则返回0表示不用等待
2.如果cv!=cu且tv!=tu，则返回min(tv,tu)-time，表示两点颜色不同但只需要等最先变色的那个点变色即可
3.如果cv!=cu且tv=tu，说明两个点颜色不同且同时变色，这时需要再求一遍wait来判断是当前是还未进入两点颜色变化周期的巧合（如某点还处于初始状态）还是两点颜色确实不可能相同，在wait函数中加入标记变量flag表示是否已经求u到v的wait函数值，如果做两边wait都是cv!=cu且tv=tu说明两点颜色不可能相同，返回INF表示等待时间无穷大
至于最短路径只需在松弛的时候记录每点前驱即可
Code

#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
#define maxn 333
#define INF 0x3f3f3f
struct node
{
    char s[3];
    int c,r,tb,tp;
}a[maxn];
int s,t,n,m,map[maxn][maxn],dis[maxn],vis[maxn],pre[maxn];
void color(int x,int time,int &cx,int &tx)
{
    if(time<a[x].r)
    {cx=a[x].c,tx=a[x].r;return ;}
    int last=(time-a[x].r)%(a[x].tb+a[x].tp);
    time-=last;
    if(a[x].c==0)
    {
        if(last<a[x].tp){cx=1,tx=time+a[x].tp;return ;}
        else {cx=0,tx=time+a[x].tb+a[x].tp;return ;}
    }
    else 
    {
        if(last<a[x].tb){cx=0,tx=time+a[x].tb;return ;}
        else {cx=1,tx=time+a[x].tb+a[x].tp;return ;}
    }
}
int wait(int u,int v,int time,int flag)
{
    int cu,tu,cv,tv;
    color(u,time,cu,tu),color(v,time,cv,tv);
    if(cu==cv)return time;
    if(tu==tv)
    {
        if(flag==0)return wait(u,v,tu,1);
        if(time<=a[u].r||time<=a[v].r)return wait(u,v,tu,1);
        return INF;
    }
    return min(tu,tv);
}
void spfa()
{
    memset(vis,0,sizeof(vis));
    for(int i=1;i<=n;i++)dis[i]=INF;
    vis[s]=1,dis[s]=0,pre[s]=0;
    queue<int>que;
    que.push(s);
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        for(int v=1;v<=n;v++)
            if(map[u][v]!=INF)
            {
                int temp=wait(u,v,dis[u],0);
                if(temp>=INF)continue;
                if(temp+map[u][v]<dis[v])
                {
                    dis[v]=temp+map[u][v];
                    pre[v]=u;
                    if(!vis[v])
                    {
                        que.push(v);
                        vis[v]=1;
                    }
                }
            }
        vis[u]=0;
    }
    if(dis[t]>=INF)printf("0\n");
    else
    {
        printf("%d\n",dis[t]);
        int res=0,ans[maxn];
        while(pre[t]!=0)
        {
            ans[res++]=t;
            t=pre[t];
        }
        printf("%d",s);
        for(int i=res-1;i>=0;i--)
            printf(" %d",ans[i]);
        printf("\n");
    }
    return ;
}
int main()
{
    while(~scanf("%d%d",&s,&t))
    {
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                map[i][j]=INF;
        for(int i=1;i<=n;i++)
        {
            scanf("%s%d%d%d",a[i].s,&a[i].r,&a[i].tb,&a[i].tp);
            if(a[i].s[0]=='B')a[i].c=0;
            else a[i].c=1;
        }
        while(m--)
        {
            int u,v,c;
            scanf("%d%d%d",&u,&v,&c);
            map[u][v]=map[v][u]=c;
        }
        spfa();
    } 
    return 0;
}