POJ 3295 Wormholes (ShortestPath.Bellman-Ford)

你妹啊，终于过了。

题目的意思是要判断一个图中是否有负权回路，由于太菜，最先想到的是 Floyd-Warshall 算法，求出每个点到每个点的最短距离。毫无疑问TLE了。

发现应该用 Bellman-Ford 之后，最先以为把每个点作为源点，然后才能判断是否有负权回路，还是 TLE。

其实只要把其中某个点作为源点，就能判断是否有负权回路。

Bellman-Ford 的步骤：

（1）循环 N - 1 次， 其中 N 是图中点的个数。每次循环对每条边进行松弛（relaxation）。

（2）对每条边判断是否有负权回路。

其中对边 (u, v) 的松弛过程是这样的：

dist [ v ] = min( dist [ v ], dist[ u ] + cost [ u ][ v ] );

判断是否有负权回路的方法是这样的：

若 dist [ v ] > dist[ u ] + cost [ u ][ v ]， 则有负权回路。因为在松弛完成后，若无负权回路，dist [ v ] 肯定是最小的。

#include<cstdio>
#include<climits>
#include<algorithm>
#define FOR(i, N) for(int i = 0; (i) < (N); (i)++)
#define FOR_2(i, N) for(int i = 1; (i) <= (N); (i)++)
using namespace std;

typedef struct{
	int v, u;
	int cost;
} EDGE;

EDGE e[6000];
int d[600];

void init(int N){
	FOR_2(i, 5800){
		e[i].v = e[i].u = 0;
		e[i].cost = INT_MAX / 10;
	}
}

void read(int M, int W){
	int t = 0;
	FOR(i, M){
		int x, y, c;
		scanf("%d%d%d", &x, &y, &c);
		e[t].v = e[t+1].u = x;
		e[t].u = e[t+1].v = y;
		e[t].cost = e[t + 1].cost = c;
		t += 2;
	}
	FOR(i, W){
		int x, y, c;
		scanf("%d%d%d", &x, &y, &c);
		e[t].v = x;
		e[t].u = y;
		e[t].cost = -c;	
		t++;
	}
}

bool bellmanFord(int s, int N){
	FOR_2(i, N)
		d[i] = INT_MAX / 100;
	d[s] = 0;
	FOR(i, N - 1){
		bool flag = false;
		int j = 0;
		while(e[j].v != 0){
			d[e[j].v] = min(d[e[j].v], d[e[j].u] + e[j].cost);
			flag = true;
			j++;
		}
		if(!flag)
			break;
	}
	int i = 0;
	while(e[i].v != 0){
		if(d[e[i].v] > d[e[i].u] + e[i].cost)
			return false;
		i++;
	}
	return true;
}

int main(){
	int F;
	scanf("%d", &F);
	while(F--){
		int N, M, W;
		scanf("%d%d%d", &N, &M, &W);
		init(N);
		read(M, W);
		bool found = false;
		if(!bellmanFord(1, N))	
			printf("YES\n");
		else	
			printf("NO\n");
	}
}