POJ 3259 Wormholes（判负圈）

Wormholes

Description

While exploring his many farms, Farmer John has discovered a number of amazing wormholes. A wormhole is very peculiar because it is a one-way path that delivers you to its destination at a time that is BEFORE you entered the wormhole! Each of FJ's farms comprises N (1 ≤ N ≤ 500) fields conveniently numbered 1..N, M (1 ≤ M ≤ 2500) paths, and W (1 ≤ W ≤ 200) wormholes.

As FJ is an avid time-traveling fan, he wants to do the following: start at some field, travel through some paths and wormholes, and return to the starting field a time before his initial departure. Perhaps he will be able to meet himself :) .

To help FJ find out whether this is possible or not, he will supply you with complete maps to F (1 ≤ F ≤ 5) of his farms. No paths will take longer than 10,000 seconds to travel and no wormhole can bring FJ back in time by more than 10,000 seconds.

Input

Line 1: A single integer,  F.  F farm descriptions follow. 
Line 1 of each farm: Three space-separated integers respectively:  N,  M, and  W 
Lines 2.. M+1 of each farm: Three space-separated numbers ( S,  E,  T) that describe, respectively: a bidirectional path between  S and  E that requires  T seconds to traverse. Two fields might be connected by more than one path. 
Lines  M+2.. M+ W+1 of each farm: Three space-separated numbers ( S,  E,  T) that describe, respectively: A one way path from  S to  E that also moves the traveler back  T seconds.

Output

Lines 1.. F: For each farm, output "YES" if FJ can achieve his goal, otherwise output "NO" (do not include the quotes).

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

题目大意：FJ的农场里出现了一些虫洞，虫洞很奇特，它是单向的并且当FJ进入虫洞时它会将FJ送到他回到之前某个时间点。农场里还有一些道路，这些道路是双向的，通过这些道路会花费一些时间。问FJ能否在农场里遇见以前的自己。

解题思路：将普通道路建双向边，权值为正；将虫洞建单向边，权值为负。然后判断图上有无负圈即可。如果有负圈，说明时间会不断减少，肯定可以遇到以前的自己。

代码如下：

Bellman_ford判负圈

<pre name="code" class="cpp">#include <cstdio>
#include <climits>
#include <cstring>
#define INF INT_MAX / 10
#define MOD 10000
const int maxn = 505;
const int maxm = 5555;
int d[maxn];
int N,M,W,cnt;
struct edge
{
	int from,to,cost;
};
edge edges[maxm];

void add_edge(int from,int to,int cost)
{
	edges[cnt].from = from;
	edges[cnt].to = to;
	edges[cnt++].cost = cost;
}

bool find_negative_loop()
{
	memset(d,0,sizeof(d));
	for(int i = 0;i < N;i++){
		for(int j = 0;j < cnt;j++){
			edge e = edges[j];
			if(d[e.to] > d[e.from] + e.cost){
				d[e.to] = d[e.from] + e.cost;
				if(i == N - 1) return true;
			}
		}
	}
	return false;
}

int main()
{
	int a,b,c,t;
	scanf("%d",&t);
	while(t--){
		scanf("%d %d %d",&N,&M,&W);
		cnt = 0;
		for(int i = 0;i < M;i++){
			scanf("%d %d %d",&a,&b,&c);
			add_edge(a,b,c);
			add_edge(b,a,c);
		}
		for(int i = 0;i < W;i++){
			scanf("%d %d %d",&a,&b,&c);
			add_edge(a,b,-c);
		}
		printf("%s\n",find_negative_loop() ? "YES" : "NO");
	}
	return 0;
}

SPFA判负圈

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <climits>
#define INF INT_MAX
#define MOD 10000
const int maxn = 505;
const int maxm = 5555;
typedef std::pair<int,int> P;
int first[maxn],d[maxn],inque[maxn],cnt[maxn],e;
int next[maxm],v[maxm],w[maxm];
int N,M,W;
void init()
{
	memset(first,-1,sizeof(first));
	e = 0;
}

void add_edge(int from,int to,int cost)
{
	v[e] = to;
	next[e] = first[from];
	w[e] = cost;
	first[from] = e++;
}

std::queue<int> que;
bool find_negative_loop()
{
	while(que.size()) que.pop();
	memset(inque,0,sizeof(inque));
	memset(cnt,0,sizeof(cnt));
	for(int i = 0;i < N;i++)
		que.push(i),d[i] = 0;
	inque[0] = 1;
	while(que.size()){
		int u = que.front();
		que.pop();
		inque[u] = 0;
		for(int i = first[u];i != -1;i = next[i]){
			if(d[v[i]] > d[u] + w[i]){
				d[v[i]] = d[u] + w[i];
				if(!inque[v[i]]){
					que.push(v[i]),inque[v[i]] = 1;
					if(++cnt[v[i]] > N) return true;
				}
			}
		}
	}
	return false;
}

int main()
{
	int a,b,c,t;
	scanf("%d",&t);
	while(t--){
		init();
		scanf("%d %d %d",&N,&M,&W);
		for(int i = 0;i < M;i++){
			scanf("%d %d %d",&a,&b,&c);
			add_edge(--a,--b,c);
			add_edge(b,a,c);
		}
		for(int i = 0;i < W;i++){
			scanf("%d %d %d",&a,&b,&c);
			add_edge(a-1,b-1,-c);
		}
		printf("%s\n",find_negative_loop() ? "YES" : "NO");
	}
	return 0;
}