SGU103 The traffic lights 绞脑题

题意：一张有向图，给出起点和终点。每个点有个交通灯，可能是蓝色或紫色（什么鬼。。）。每个点的蓝色和紫色各有一个持续时间（每个点的交通灯数据不一定相同），并且有一个0时刻的初始颜色以及初始颜色剩余的持续时间（毛子干嘛非要把题目弄这么复杂）。每条道路有一个非负整数的长度。从一个节点到另一个节点，当且仅当这两个节点的交通灯颜色相同，也就是说如果到了一个节点，想要去另一个节点而那个节点和这个颜色不同，需要等待一定的时间。求起点到终点的最短路长度和路径上经过的节点，如不连通输出一个零。

开始的时候想了一下建模后跑最短路之类的，发现不太现实。

然后想了一下这题的状态转移方程：dis[v] = min(dis[v], wait+dis[u][v]); 其中wait是一个不定量，表示等待至的时间（显然≥dis[u]）。

对于这种题，有向图上有状态转移方程，需要将每个节点的状态值最优化，但是有环不方便转移也不能强连通缩点时，一种比较通用的写法就是根据SPFA的思想，若一个点被更新，则将它通向的点压入队列待更新（NOIP2009最优贸易一题可以用此方法代替tarjan缩点）。这道题而言，若一个点的距离值变小（松弛成功），就将临界点压入队列。当然，可以看出这题就是一个最短路，所以dijkstra也是可以的，但是dijkstra对于有向图上无规则DP的通用性不如SPFA。

然后还有就是怎么判定时间，这点非常绕脑袋。一定要认真推算。注意永远不相等的判定，只要连续三个周期不相等即可（我一开始想了半天，不是很好直接表示，后来在网上找到的这种判定方法）。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int MAXN = 305, MAXM = 28050;
const int INF = 0x3f3f3f3f;

struct Node {
	int to, d;
	Node*next;
}Edge[MAXM], *ecnt=Edge, *adj[MAXN];
void adde(int a, int b, int d)
{
	(++ecnt)->to = b;
	ecnt->d = d;
	ecnt->next = adj[a];
	adj[a] = ecnt;
}

int S, T, N, M;
int oc[MAXN]; //original color, 0 for blue and 1 for purple
int rest[MAXN], tb[MAXN], tp[MAXN];
int dis[MAXN], pre[MAXN];
int rou[MAXM], rn;

inline int color(int u, int t)
{
	if (t < rest[u]) return oc[u];
	t = (t - rest[u]) % (tb[u]+tp[u]);
	if (oc[u]==0) return t<tp[u] ? 1 : 0;
	return t<tb[u] ? 0 : 1;
}

inline int nexttm(int u, int t)//下一次变色时间
{
	int t1;
	if (t < rest[u]) t1 = rest[u];
	else {
		t1 = (t - rest[u]) % (tb[u]+tp[u]);
		if (oc[u]==0) {
			if (t1 < tp[u]) t1 = t+tp[u]-t1;
			else t1 -= tp[u], t1 = t+tb[u]-t1;
		}
		else {
			if (t1 < tb[u]) t1 = t+tb[u]-t1;
			else t1 -= tb[u], t1 = t+tp[u]-t1;
		}
	}
	return t1;
}

bool relax(int u, int v, int d)
{
	if (dis[v] < dis[u]) return 0;
	int c1 = color(u, dis[u]), c2 = color(v, dis[u]);
	if (c1 == c2) {
		if (dis[u]+d < dis[v]) { dis[v] = dis[u]+d; return 1; }
			return 0;
	}
	else {
		int t1 = dis[u], t2 = dis[u], wait = -1, t;
		for (int i = 1; i<4; ++i)
		{
			t1 = nexttm(u, t1);
			t2 = nexttm(v, t2);
			if (t1==t2) continue;
			t = t1 < t2 ? t1 : t2;
			if (color(u, t) == color(v, t)) { wait = (t1<t2?t1:t2); break; }
		}
		if (wait==-1 || wait+d>=dis[v]) return 0;
		dis[v] = wait + d;
		return 1;
	}
}

queue<int> Q;
bool inq[MAXN];
void SPFA()
{
	memset(dis, 0x3f, sizeof dis);
	Q.push(S);
	inq[S] = 1; dis[S] = 0;
	while (!Q.empty()) {
		int u = Q.front();
		Q.pop(); inq[u] = 0;
		for (Node*p = adj[u]; p; p=p->next)
			if (relax(u, p->to, p->d)) {
				pre[p->to] = u;
				if (!inq[p->to])
					Q.push(p->to), inq[p->to] = 1;
			}
	}
}

int main()
{
	int a, b, c;
	scanf("%d%d%d%d", &S, &T, &N, &M);
	if (S==T) { printf("0\n%d\n", S); return 0; }
	char str[5];
	for (int i = 1; i<=N; ++i) {
		scanf("%s%d%d%d", str, rest+i, tb+i, tp+i);
		oc[i] = (str[0]=='P');
	}
	for (int i = 1; i<=M; ++i)
	{
		scanf("%d%d%d", &a, &b, &c);
		adde(a, b, c); adde(b, a, c);
	}
	SPFA();
	if (dis[T]>=INF) { puts("0"); return 0; }
	printf("%d\n", dis[T]);
	a = T;
	do { rou[++rn] = a; a = pre[a]; } while (a);
	for (int i = rn; i>=1; --i)
		printf("%d%c", rou[i], i==1?'\n':' ');
	return 0;
}