POJ 3259 Wormholes(SPFA算法判断是否存在负环)
| Time Limit: 2000MS | Memory Limit: 65536K | |
| Total Submissions: 36755 | Accepted: 13457 |
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 toF (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 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 toE that also moves the traveler backT seconds.
Output
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 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.
题意：有n个地点，编号1到n。 有m行S ，E， T。表示从地点S(E)到地点E(S)的时间为T。 有w个虫洞，通过虫洞可以从S穿越到到E（单向穿越），且时间回到T秒前。问是否存在从一点出发，回到这一点看到从前的自己。
解题思路：先建图，能从虫洞穿越的路径的权值可以看成负值，若要回到起始点，且时间倒退，路径一定是至少经过一条负权值边的环，解答此题即为判断是否存在负值环即可。
SPFA算法，代码如下：
#include<cstdio>
#include<queue>
using namespace std;
#define INF 0x3f3f3f
#define maxn 510
#define maxm 5510
int dis[maxn],visit[maxn],head[maxn],top,n;
struct node
{
int to,val,next;
}edge[maxm];
void add(int a,int b,int c)
{
edge[top].to=b;
edge[top].val=c;
edge[top].next=head[a];
head[a]=top++;
}
void spfa()
{
int mark[maxn];//记录一个点入队列的次数
int i,u,v;
for(i=1;i<=n;++i)
{
mark[i]=0;
dis[i]=INF;
visit[i]=0;
}
queue<int>q;
q.push(1);
dis[1]=0;
visit[1]=1;
mark[1]++;
while(!q.empty())
{
u=q.front();
q.pop();
visit[u]=0;
for(i=head[u];i!=-1;i=edge[i].next)
{
v=edge[i].to;
if(dis[v]>dis[u]+edge[i].val)
{
dis[v]=dis[u]+edge[i].val;
if(!visit[v])
{
visit[v]=1;
mark[v]++;
q.push(v);
if(mark[v]>=n)//图中有负环
{
printf("YES\n");
return ;
}
}
}
}
}
printf("NO\n");
}
int main()
{
int m,w,a,b,c,i,t;
scanf("%d",&t);
while(t--)
{
scanf("%d%d%d",&n,&m,&w);
top=0;
for(i=1;i<=n;++i)
head[i]=-1;
while(m--)
{
scanf("%d%d%d",&a,&b,&c);
add(a,b,c);
add(b,a,c);
}
while(w--)
{
scanf("%d%d%d",&a,&b,&c);
add(a,b,-c);
}
spfa();
}
return 0;
}