SGU 103 略复杂的单源最短路

题目链接点这儿

总体来说就是求一个单源最短路，有关单源最短路的spfa算法点这儿

麻烦的地方就在于每个点都有两种状态，必须两个点都在同一个状态时才能转移，如果当你到达那个点，无法移动时，可以等到两点到达同一状态再移动。

分情况真的好麻烦。。。先要求出到达那个点时，两个点的状态。如果状态不一样，要分别求出两个点下一次转换状态的时间。就取其中较小拿来用就行，但是。。。它俩下次转换的时间还可能一样。。。所以如果一样的话。。。还要再求下下次转换的时间。。。如果这次还一样的话。。。那么它俩就不可能同时处于一种状态了。。。这时就意味着这条路不通了。

处理完上述的分类，这题直接spfa上就可以了。

下面是代码

#include <bits/stdc++.h>
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)>(b)?(b):(a))
#define rep(i,initial_n,end_n) for(int (i)=(initial_n);(i)<(end_n);i++)
#define repp(i,initial_n,end_n) for(int (i)=(initial_n);(i)<=(end_n);(i)++)
#define reep(i,initial_n,end_n) for((i)=(initial_n);(i)<(end_n);i++)
#define reepp(i,initial_n,end_n) for((i)=(initial_n);(i)<=(end_n);(i)++)
#define eps 1.0e-9
#define MAX_N 500

using namespace std;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef long long ll;
typedef unsigned long long ull;

int n, m, pre[310], src, dest, t[310][2], ini[310], dis[310], init[310];
vector<pii> edge[310];

void spfa();
int check(int i, int now);
int next(int i, int now);

int main() {
    scanf("%d%d", &src, &dest);
    scanf("%d%d", &n, &m);
    repp(i, 1, n) {
        char c[5];
        scanf("%s%d%d%d", c, &ini[i], &t[i][0], &t[i][1]);
        if(c[0] == 'B') init[i] = 0;
        else init[i] = 1;
    }
    int one, two, cost;
    rep(i, 0, m) {
        scanf("%d%d%d", &one, &two, &cost);
        edge[one].push_back(make_pair(two, cost));
        edge[two].push_back(make_pair(one, cost));
    }
    spfa();
    if(dis[dest] == INT_MAX) { puts("0"); exit(0); }
    printf("%d\n", dis[dest]);
    stack<int> s; s.push(dest);
    while(pre[dest] != -1) s.push(pre[dest]), dest = pre[dest];
    while(1) {
        printf("%d", s.top());
        s.pop();
        if(s.empty()) { puts(""); break; }
        else putchar(' ');
    }
    return 0;
}

int check(int i, int now) {
    if(now < ini[i]) return init[i];
    else {
        now = (now - ini[i]) % (t[i][0] + t[i][1]);
        if(now < t[i][1 - init[i]]) return 1 - init[i];
        else return init[i];
    }
}

int next(int i, int now) {
    if(now < ini[i]) return ini[i] - now;
    else {
        now = (now - ini[i]) % (t[i][0] + t[i][1]);
        if(now < t[i][1 - init[i]]) return t[i][1 - init[i]] - now;
        else return t[i][0] + t[i][1] - now;
    }
}

void spfa() {
    fill(dis, dis + n + 1, INT_MAX);
    dis[src] = 0, pre[src] = -1;
    queue<int> q;
    q.push(src);
    while(!q.empty()) {
        int tmp = q.front(), len = edge[tmp].size();
        q.pop();
        rep(i, 0, len) {
            int tmpp = edge[tmp][i].first, tmp_dis;
            int  s1 = check(tmp, dis[tmp]), s2 = check(tmpp, dis[tmp]);
            tmp_dis = dis[tmp] + edge[tmp][i].second;
            if(s1 != s2) {
                int t1 = next(tmp, dis[tmp]), t2 = next(tmpp, dis[tmp]), t3, t4;
                tmp_dis += min(t1, t2);
                if(t1 == t2) {
                    t3 = next(tmp, dis[tmp] +t1), t4 = next(tmpp, dis[tmp] + t1);
                    if(t3 == t4) tmp_dis = INT_MAX;
                    else tmp_dis += min(t3, t4);
                }
            }
            if(tmp_dis < dis[tmpp]) {
                pre[tmpp] = tmp;
                dis[tmpp] = tmp_dis;
                q.push(tmpp);
            }
        }
    }
}