UVA 10048 A - 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
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.

农场出现了单向的虫洞农场主john能否通过虫洞看到原来的自己。
用bellman ford判断是否有负环。

#include<stdio.h>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
int N,M,W,Count;
int s[5400],e[5400],t[5400];
int d[5400];
void Bellman_Ford()
{
    d[1]=0;
    int i=0;
    bool flag=false;
     for(int i=0;i<=N;i++)
     {
         flag=false;
         for(int j=0;j<Count;j++)
         {
             if(d[e[j]]>d[s[j]]+t[j])
             {
                 d[e[j]]=d[s[j]]+t[j];
                 flag=true;
             }
         }
         if(!flag)
             break;
     }
     for(int j=0;j<Count;j++)
     {
         if(d[e[j]]>d[s[j]]+t[j])
         {
             cout<<"YES"<<endl;
             return;
         }
     }
     cout<<"NO"<<endl;
}
int main()
{
    int F;
    cin>>F;
    while(F--)
    {
        Count=0;
        cin>>N>>M>>W;
        for(int i=0;i<2*(M+W);i++)
        {
            s[i]=99999;
            e[i]=99999;
            t[i]=99999;
            d[i]=99999;
        }
        for(int i=0;i<M;i++)
        {
            cin>>s[Count]>>e[Count]>>t[Count];
            Count++;
            s[Count]=e[Count-1];
            e[Count]=s[Count-1];
            t[Count]=t[Count-1];
            Count++;
        }
        for(int i=0;i<W;i++)
        {
            cin>>s[Count]>>e[Count]>>t[Count];
            t[Count]=-t[Count];
            Count++;
        }
        Bellman_Ford();
    }
    return 0;
}