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
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.
题目大意
给你三个数n,m,w，分别表示有n个农场，m条路，w个黑洞，接下来m行分别有三个数s，e，val表示s到e有一条权值为val 的边，接下来的w行每行有三个数s，e，val表示s到e有一条权值为0-val的边，因为黑洞可以回到过去，所以其权值为负。现在问你给你这些点，求每组数据是否存在一条回路能使时间倒退。
思路
问你是否存在一条回路能使时间倒退。那么充要条件就是图中一定存在一条负环，可以用bellman-ford算法，也可以用优化后的SPFA算法。只要图中存在负环即返回true，表示存在这样一条回路。
SPFA详解见：http://blog.csdn.net/acm_1361677193/article/details/48211319
更新与2016/8/18
这题也可以用Bellman_Ford做，实际上SPFA是Bellman_Ford的优化。如果看不懂SPFA可以参考Bellman_Ford，比较容易理解。思路就是寻找一条负权边，因为负权边在松弛时可以无限松弛，所以只要判断是否存在一条可以无限松弛的负权边就可以了。
代码
SPFA：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int maxn=500+5;
const int maxe=6000+5;
const int INF=0x7fffffff;
struct proc
{
int v,w;
int next;
};
proc edge[maxe];
int dis[maxn],vis[maxn],f,n,m,w,head[maxe];
int cnt[maxn];
int k;
void addEdge(int u,int v,int w)
{
edge[k].v=v;
edge[k].w=w;
edge[k].next=head[u];
head[u]=k++;
}
bool spfa()
{
for(int i=0;i<=n;i++)
{
dis[i]=INF;
}
memset(cnt,0,sizeof(cnt));
memset(vis,0,sizeof(vis));
queue<int> q;
vis[1]=1;
dis[1]=0;
cnt[1]=1;
q.push(1);
while(!q.empty())
{
int cur=q.front();
q.pop();
vis[cur]=false;
for(int i=head[cur];i+1;i=edge[i].next)
{
int id=edge[i].v;
if(dis[cur]+edge[i].w<dis[id])
{
dis[id]=dis[cur]+edge[i].w;
if(!vis[id])
{
cnt[id]++;
if(cnt[cur]>=n)
return false;
vis[id]=true;
q.push(id);
}
}
}
}
return true;
}
int main()
{
while(~scanf("%d",&f))
{
while(f--)
{
scanf("%d %d %d",&n,&m,&w);
k=0;
memset(head,-1,sizeof(head));
int s,e,val;
for(int i=0;i<m;i++)
{
scanf("%d %d %d",&s,&e,&val);
addEdge(s,e,val);
addEdge(e,s,val);
}
for(int i=0;i<w;i++)
{
scanf("%d %d %d",&s,&e,&val);
addEdge(s,e,0-val);
}
if(spfa()) printf("NO\n");
else printf("YES\n");
}
}
}更新于2016/8/18
Bellman_Ford：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxv=500+5;
const int maxe=6000+5;
const int INF=0x3f3f3f3f;
struct proc
{
int s,e,t;
}edge[maxe];
int n,m,w,dis[maxv];
int cnt;
void addEdge(int s,int e,int t)
{
edge[cnt].s=s;
edge[cnt].e=e;
edge[cnt++].t=t;
}
int bell_man()
{
bool flag;
//松弛
for(int i=1;i<=n;i++)
{
flag=false;
for(int j=1;j<=cnt;j++)
{
if(dis[edge[j].e]>dis[edge[j].s]+edge[j].t)
{
dis[edge[j].e]=dis[edge[j].s]+edge[j].t;
flag=true;
}
}
if(!flag) break;
}
//寻找负环，判断条件是负环可以无限松弛。
for(int i=1;i<=cnt;i++)
{
if(dis[edge[i].e]>dis[edge[i].s]+edge[i].t)
{
return true;
}
}
return false;
}
int main()
{
int s,e,v;
int cas;
scanf("%d",&cas);
while(cas--)
{
memset(dis,INF,sizeof(dis));
cnt=1;
scanf("%d %d %d",&n,&m,&w);
for(int i=1;i<=m;i++)
{
scanf("%d %d %d",&s,&e,&v);
addEdge(s,e,v);
addEdge(e,s,v);
}
for(int i=1;i<=w;i++)
{
scanf("%d %d %d",&s,&e,&v);
addEdge(s,e,0-v);
}
int ans=bell_man();
if(ans) printf("YES\n");
else printf("NO\n");
}
return 0;
}