POJ 3259 Wormholes

虫洞是很奇特的，因为它是一个**单向**通道，可让你进入虫洞的前达到目的地！他的N（1≤N≤500）个农场被编号为1..N，之间有M（1≤M≤2500）条路径，W（1≤W≤200）个虫洞。FJ作为一个狂热的时间旅行的爱好者，他要做到以下几点：开始在一个区域，通过一些路径和虫洞旅行，他要回到最开时出发的那个区域出发前的时间。也许他就能遇到自己了:)。为了帮助FJ找出这是否是可以或不可以，他会为你提供F个农场的完整的图（1≤F≤5）。所有的路径所花时间都不大于10000秒，所有的虫洞都回到不大于10000秒之前。

Input

第1行：一个整数F表示接下来会有F个农场说明。 每个农场第一行：分别是三个空格隔开的整数：N，M和W 第2行到M+1行：三个空格分开的数字（S，E，T）描述，分别为：需要T秒走过S和E之间的双向路径。两个区域可能由一个以上的路径来连接。 第M +2到M+ W+1行：三个空格分开的数字（S，E，T）描述虫洞，描述单向路径，S到E且回溯T秒。

Output

F行，每行代表一个农场 每个农场单独的一行，” YES”表示能满足要求，”NO”表示不能满足要求。

Sample Input

2
3 3 1
1 2 2
1 3 4
2 3 1
3 1 3
3 2 1
1 2 3
2 3 4
3 1 8

Sample Output

NO
YES

Hint

For farm 1, FJ cannot travel back in time. 
For farm 2, FJ could travel back in time by the cycle 1->2->3->1, arriving back at his starting location 1 second before he leaves. He could start from anywhere on the cycle to accomplish this.

判断是否有环，和POJ1860差不多，Floyd正好可以过，最好用Bellman吧。

Floyd

#include <stdio.h>
#include <string.h>
#define inf 0x3f3f3f3f
int e[505][505];
bool Floyd(int n) {
	int time = inf;
	for(int k = 1; k <= n; k++) {
		for(int i = 1; i <= n; i++) {
			for(int j = 1; j <= n; j++) {
				time = e[i][k] + e[k][j];
				if(time < e[i][j]) {
					e[i][j] = time;
				}
			}
			if(e[i][i] < 0) return true;//表示与自己相遇 
		}
	}
	return false;
}
int main() {
	int Case;
	int N, M, W;
	int S, E, T;
	scanf("%d", &Case);
	while(Case--) {
		memset(e, inf, sizeof(e));
		scanf("%d %d %d", &N, &M, &W);
		for(int i = 1; i <= N; i++) e[i][i] = 0;
		for(int i = 0; i < M; i++) {
			scanf("%d %d %d", &S, &E, &T);//从S到E花费时间T，并且是双向路径 
			if(T < e[S][E]) {
				e[S][E] = e[E][S] = T;
			}
		}
		for(int i = 0; i < W; i++) {
			scanf("%d %d %d",&S, &E, &T);//从S到E穿梭到T秒前，单向路径 
			e[S][E] = -T;
		}
		if(Floyd(N)) printf("YES\n");
		else printf("NO\n");
	}
	return 0;
}

Bellman ，不得不说，这道题很坑，我RE了二十多发，最后因为一个莫名其妙的bug，颠覆了我的ACM观，具体的bug我会在代码中指出来，我还没有解决，如果有哪位大佬知道原因，请指点我一下，我将不胜感激！在此先谢谢。

#include <stdio.h>
#include <string.h>
#include <iostream>//不带这个头文件，RE ，我好像没有用到这个头文件，为何RE？
using namespace std;
#define inf 0x3f3f3f3f
int dis[505];//放在这里不RE
struct node{
	int S, E, T;
	void Node(int s, int e, int t) {
		S = s; E = e; T = t;
	}
}e[3550];
//int dis[505];//放在这里RE 
bool Bellman(int n, int t) {
	for(int i = 1; i < n; i++) {
		bool flag = false;
		for(int j = 0; j < t; j++) {
			int u = e[j].S;
			int v = e[j].E;
			if(dis[v] > (dis[u] + e[j].T)) {
				dis[v] = dis[u] + e[j].T;
				flag = true;
			}
		}
		if(!flag) return false;
	}
	for(int i = 0; i < t; i++) {
		int u = e[i].S;
		int v = e[i].E;
		if(dis[v] > (dis[u] + e[i].T)) {
			return true;
		}
	}
	return false;
}
int main() {
	int Case;
	int N, M, W;
	int S, E, T;
	scanf("%d",&Case);
	while(Case--) {
		scanf("%d %d %d", &N, &M, &W);
		int t = 0;
		for(int i = 0; i < M; i++) {
			scanf("%d %d %d", &S, &E, &T);
			e[t++].Node(S, E, T);
			e[t++].Node(E, S, T);
		}
		for(int i = 0; i < W; i++) {
			scanf("%d %d %d", &S, &E, &T);
			e[t++].Node(S, E, -T);
		}
		memset(dis, inf, sizeof(dis));
		dis[N] = 0;
		if(Bellman(N, t)) printf("YES\n");
		else printf("NO\n");
	}
	return 0;
}