F - Wormholes（Bellmanford判负环）

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

题解：

Bellman-Ford判负环。
很好玩的虫洞问题。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;

const int INF = 0x3f3f3f3f;
const int maxn = 550;
int dist[maxn];

struct Edge
{
    int u;
    int v;
    int cost;
    Edge(int _u,int _v,int _cost):u(_u),v(_v),cost(_cost){}
};

vector<Edge> E;

bool BellmanFord(int start,int n)
{
   memset(dist,0x3f,sizeof(dist));
   dist[start]=0;

   for(int i=1;i<n;i++)
   {
       bool flag = false;
       for(int j=0;j<E.size();j++)
       {
           int u = E[j].u;
           int v = E[j].v;
           int cost = E[j].cost;
           if(dist[v]>dist[u]+cost)
           {
               dist[v] = dist[u]+cost;
               flag = true;
           }
       }
       if(!flag) return true;
   }

   for(int j=0;j<E.size();j++)
   {
       if(dist[E[j].v]>dist[E[j].u]+E[j].cost)
       {
           return false;
       }
   }
   return true;
}

int main()
{
    int T;
    scanf("%d",&T);
    int N,M,W;
    while(T--)
    {
       scanf("%d%d%d",&N,&M,&W);

       int u,v,t;

       for(int i=1;i<=M;i++)
       {
        scanf("%d%d%d",&u,&v,&t);
        E.push_back(Edge(u,v,t));
        E.push_back(Edge(v,u,t));
       }

       for(int i=1;i<=W;i++)
       {
           scanf("%d%d%d",&u,&v,&t);
           E.push_back(Edge(u,v,-t));
       }

       bool flag = BellmanFord(1,N);
       if(flag) cout<<"NO"<<endl;
       else cout<<"YES"<<endl;
          E.clear();
    }
    return 0;
}