【POJ 3259】Wormholes 负环 SPFA+Bellman-Ford

Wormholes

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 68247		Accepted: 25425

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

题意：先输入F，代表F个农场，其实就是F组数据。接下来N，M，W代表有N个点，M条边，W个虫洞。接下来M行，每行三个数字S，E，T代表从S到E所花的时间T。再接下来W行代表W个虫洞，每行三个数字S，E，T代表从S到E所倒退的时间T,问你能不能通过走图来回到比自己开始出发的时间以前。

题解：分析一下，要是我们走了一会儿，再通过虫洞回到以前，除非能把之前走的时间抵消掉，怎么才能抵消掉呢，除非图中有负环，这样我们通过走负环，来倒退时间，就能回到自己出发的那个时间以前遇到自己。SPFA算法和Bellman-Ford算法都能判断图中是否存在负环。

SPFA：

#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=1000+7;
const int INF=1<<29;
int cost[maxn][maxn];
int low[maxn];      //每个点的最短路
int cnt[maxn];    //记录每个点入队次数
int q[maxn*maxn];  //队列
int vis[maxn];   //记录某个结点是否在队列
int n,m,t,u,v,w;
int SPFA()
{
    for(int i=0;i<n;i++)  low[i]=INF;   //其余点到源点的距离初始化为无穷大
    low[0]=0;   //源点距离初始化为0
    for(int i=0;i<n;i++)  cnt[i]=0;    //入队次数统计
    for(int i=0;i<n;i++)  vis[i]=0;    //结点开始都没在队列
    int head=0,tail=0;          
    q[tail++]=0;
    cnt[0]++;
    while(head<tail){
        int cur=q[head++];   //取队首
        vis[cur]=0;       //队首就不在队列
        for(int i=0;i<n;i++){
            if(low[cur]+cost[cur][i]<low[i]){     //松弛
                low[i]=low[cur]+cost[cur][i];
                if(!vis[i]){
                    q[tail++]=i;     //入队
                    cnt[i]++;
                    if(cnt[i]>n) return 1;   //入队次数大于n
                }
            }
        }
    }
    return 0;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d %d %d",&n,&m,&t);
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                cost[i][j]=INF;
            }
        }
        for(int i=0;i<m;i++){
            scanf("%d %d %d",&u,&v,&w);
            if(w<cost[u-1][v-1])cost[u-1][v-1]=cost[v-1][u-1]=w;
        }
        for(int i=0;i<t;i++){
            scanf("%d %d %d",&u,&v,&w);
            cost[u-1][v-1]=-w;  //虫洞 只能从u到v
        }
        if(SPFA())printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

Bellman-Ford：

#include<cstdio>
#include<cstring>
using namespace std;
const int maxn=1000+7;
const int INF=1<<29;
int cost[maxn][maxn];
int low[maxn];
int n,m,t,u,v,w;
int Bellman_Ford()
{
    for(int i=1;i<n;i++) low[i]=INF;     //其余点无穷大
    low[0]=0;         //源点距离初始化为0
    for(int i=0;i<n-1;i++){
        for(int j=0;j<n;j++){
            for(int k=0;k<n;k++){
                if(low[j]+cost[j][k]<low[k]){
                    low[k]=low[j]+cost[j][k];
                }
            }
        }
    }
    for(int i=0;i<n;i++){              //还能再松弛 证明有负环
        for(int j=0;j<n;j++){
            if(low[i]+cost[i][j]<low[j]) return 1;
        }
    }
    return 0;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d %d %d",&n,&m,&t);
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                cost[i][j]=INF;
            }
        }
        for(int i=0;i<m;i++){
            scanf("%d %d %d",&u,&v,&w);
            if(w<cost[u-1][v-1])cost[u-1][v-1]=cost[v-1][u-1]=w;
        }
        for(int i=0;i<t;i++){
            scanf("%d %d %d",&u,&v,&w);
            cost[u-1][v-1]=-w;  //虫洞 只能从u到v
        }
        if(Bellman_Ford())printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}