poj 3259 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.

Bellman-ford算法

题意：John的农场里N块地，M条路连接两块地(双向的)，W个虫洞。虫洞是一条单向路，不但会把你传送到目的地，而且时间会倒退Ts（也就是负权边，所以我们存的是负值）。我们的任务是知道会不会在从某块地出发后又回来，看到了离开之前的自己。

思路：由于存在负权边，Dijkstra便不能用了，所以用bellman_ford。题目简化下，就是看图中有没有负权环，有的话John可以无限次走这个环，使得时间一定能得到一个负值。所以有的存在负环话就是可以，没有的话就是不可以了。

#include<iostream>

using namespace std;

struct node

{

    int u,v,val;

}p[10000];

int N,M,W,k;

int dist[501],INF=1000000;

void addedge(int u,int v,int t)

{

    p[k].u=u; p[k].v=v;  p[k].val=t;

    k++;

}

bool Bellman()

{

    for(int i=1;i<=N;i++)

        dist[i]=INF;

    dist[1]=0;

    for(int i=1;i<=N;i++)  //边的松弛

        for(int j=1;j<k;j++)

         if(dist[p[j].v]>dist[p[j].u]+p[j].val)

            dist[p[j].v]=dist[p[j].u]+p[j].val;

    for(int i=1;i<k;i++)  //查看是否存在负权边

      if(dist[p[i].v]>dist[p[i].u]+p[i].val)

       {

           return true;

       }

    return false;

}

int main()

{

    int T;

    cin>>T;

    while(T--)

    {

        int i,s,e,t;

        cin>>N>>M>>W;

        k=1;

        for(i=0;i<M;i++)

        {

            cin>>s>>e>>t;

            addedge(s,e,t);//农场间是双向的

            addedge(e,s,t);

        }

        for(i=0;i<W;i++)

        {

            cin>>s>>e>>t;

            addedge(e,s,-t);//虫洞是单向的

        }

        if(Bellman())

           cout<<"YES"<<endl;

        else

           cout<<"NO"<<endl;

    }

    return 0;

}