UVA 558 判断环 【炒鸡简单的图论题】

In the year 2163, wormholes were discovered. A wormhole is a subspace tunnel through space and time
connecting two star systems. Wormholes have a few peculiar properties:
• Wormholes are one-way only.
• The time it takes to travel through a wormhole is negligible.
• A wormhole has two end points, each situated in a star system.
• A star system may have more than one wormhole end point within its boundaries.
• For some unknown reason, starting from our solar system, it is always possible to end up in any
star system by following a sequence of wormholes (maybe Earth is the centre of the universe).
• Between any pair of star systems, there is at most one wormhole in either direction.
• There are no wormholes with both end points in the same star system.
All wormholes have a constant time difference between their end points. For example, a specific
wormhole may cause the person travelling through it to end up 15 years in the future. Another wormhole
may cause the person to end up 42 years in the past.
A brilliant physicist, living on earth, wants to use wormholes to study the Big Bang. Since warp
drive has not been invented yet, it is not possible for her to travel from one star system to another one
directly. This can be done using wormholes, of course.
The scientist wants to reach a cycle of wormholes somewhere in the universe that causes her to end
up in the past. By travelling along this cycle a lot of times, the scientist is able to go back as far in
time as necessary to reach the beginning of the universe and see the Big Bang with her own eyes. Write
a program to find out whether such a cycle exists.
Input
The input file starts with a line containing the number of cases c to be analysed. Each case starts with
a line with two numbers n and m. These indicate the number of star systems (1 ≤ n ≤ 1000) and
the number of wormholes (0 ≤ m ≤ 2000). The star systems are numbered from 0 (our solar system)
through n − 1 . For each wormhole a line containing three integer numbers x, y and t is given. These
numbers indicate that this wormhole allows someone to travel from the star system numbered x to the
star system numbered y, thereby ending up t (−1000 ≤ t ≤ 1000) years in the future.
Output
The output consists of c lines, one line for each case, containing the word ‘possible’ if it is indeed
possible to go back in time indefinitely, or ‘not possible’ if this is not possible with the given set of
star systems and wormholes.
Sample Input
2
3 3
0 1 1000
1 2 15
2 1 -42
4 4
0 1 10
1 2 20
2 3 30
3 0 -60
Sample Output
possible

not possible

【题目大意】

给出T组数据，对于每组数据输入一个n,m代表星系数量，和虫洞数量。

星系由0标号至n-1（0号星系表示我们的太阳系）

接下来m行每行输入x,y,time代表从x星系到y星系有一个单向虫洞，穿越该虫洞所需要的时间是time

输出：如果图中有负环则输出“possible”否则输出“not possible”

【解题思路】

就是判断负环，这么水的题还有什么好说的嘛~~

好吧还是说一下：只要SPFA内部进行松弛操作超过n-1次就视为出现负环。（以SPFA为例）

【代码】

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<ctime>
#include<cstring>
#include<string>
#include<cctype>
#include<iomanip>
#define LL long long
#define LOCAL
using namespace std;

const int N=10011;
int n,m,k;
struct node{
	int nxt;
	int to;
	int len;
}e[N<<1];
int first[N],p[N],dis[N],tot,cnt,s,t;
int timel=0,T;
bool exist[N];

inline void Add(int x,int y,int z){
	tot++;
	e[tot].nxt=first[x];
	first[x]=tot;
	e[tot].to=y;
	e[tot].len=z;
}

inline void Clear(){
	tot=timel=0;
	memset(first,0,sizeof(first));
	memset(dis,127,sizeof(dis));
	memset(p,0,sizeof(p));
	memset(exist,false,sizeof(exist));
}

bool SPFA(int s){
	dis[s]=0;
	int head=0;
	int tail=1;
	p[1]=s;
	exist[1]=true;
	while (head<tail){
		head++;
		exist[head]=false;
		int u=first[p[head]];
		while (u){
			if (dis[e[u].to]>dis[p[head]]+e[u].len){
				timel++;
				if (timel>=n) return true;
				dis[e[u].to]=dis[p[head]]+e[u].len;
				if (!exist[e[u].to]){
					tail++;
					p[tail]=e[u].to;
					exist[e[u].to]=true;
				}
			}
			u=e[u].nxt;
		}
	}
	return false;
}

int main(){
	scanf("%d",&T);
	while (T--){
		Clear();
		scanf("%d%d",&n,&m);
		for (int i=1;i<=m;++i){
			int x,y,z;
			scanf("%d%d%d",&x,&y,&z);
			Add(x,y,z);
		}
		if (SPFA(0)) printf("possible\n");
		else printf("not possible\n");
	}
	return 0;
}

【总结】

判断负环——松弛超过n-1次