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 backT 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.
t译文：农夫约翰在探索他的许多农场，发现了一些惊人的虫洞。虫洞是很奇特的，因为它是一个单向通道，可让你进入虫洞的前达到目的地！他的N（1≤N≤500）个农场被编号为1..N，之间有M（1≤M≤2500）条路径，W（1≤W≤200）个虫洞。作为一个狂热的时间旅行FJ的爱好者，他要做到以下几点：开始在一个区域，通过一些路径和虫洞旅行，他要回到最开时出发的那个区域出发前的时间。也许他就能遇到自己了:)。为了帮助FJ找出这是否是可以或不可以，他会为你提供F个农场的完整的映射到（1≤F≤5）。所有的路径所花时间都不大于10000秒，所有的虫洞都不大于万秒的时间回溯。

 
输入
第1行：一个整数F表示接下来会有F个农场说明。
每个农场第一行：分别是三个空格隔开的整数：N，M和W
第2行到M+1行：三个空格分开的数字（S，E，T）描述，分别为：需要T秒走过S和E之间的双向路径。两个区域可能由一个以上的路径来连接。
第M +2到M+ W+1行：三个空格分开的数字（S，E，T）描述虫洞，描述单向路径，S到E且回溯T秒。
输出
F行，每行代表一个农场
每个农场单独的一行，” YES”表示能满足要求，”NO”表示不能满足要求。
NO
YES

 

思路：

虫洞可以让 你回到过去，就相当于一个负权。然后判断是否存在负环，即走走走。。。然后又走回去了

  1 #include <stdio.h>
  2 #include <algorithm>
  3 #include <iostream>
  4 #include <stdbool.h>
  5 #include <stdlib.h>
  6 #include <string>
  7 #include <string.h>
  8 #include <math.h>
  9 #include <vector>
 10 #include <queue>
 11 #include <stack>
 12 #include <map>
 13 
 14 #define INF 0x3f3f3f3f
 15 #define LL long long
 16 #define MAXN 1000005
 17 using namespace std;
 18 
 19 typedef struct Edge{
 20     int u,v;
 21     int cost;
 22 }Edge;
 23 
 24 int nodenum,edgenum;
 25 int hole;
 26 int T;
 27 Edge edge[MAXN];
 28 int dist[MAXN],pre[MAXN];
 29 
 30 bool Bellman_Ford()
 31 {
 32     for (int i=1;i<=nodenum;i++)
 33         dist[i] = INF;
 34     dist[1] = 0;
 35     for (int i=1;i<nodenum;i++)
 36     {
 37         for (int j=1;j<=edgenum;j++)
 38         {
 39             if (dist[edge[j].v] > dist[edge[j].u]+edge[j].cost)
 40             {
 41                 dist[edge[j].v] = dist[edge[j].u]+edge[j].cost;
 42                 pre[edge[j].v] = edge[j].u;
 43             }
 44         }
 45     }
 46     bool flag = true;
 47     for (int i=1;i<=edgenum;i++)
 48     {
 49         if (dist[edge[i].v]>dist[edge[i].u]+edge[i].cost)
 50         {
 51             flag = false;
 52             break;
 53         }
 54     }
 55     return flag;
 56 }
 57 
 58 void print_path(int root)
 59 {
 60     while (root!=pre[root])
 61     {
 62         printf("%d->",root);
 63         root = pre[root];
 64     }
 65     if (root == pre[root])
 66         printf("%d\n",root);
 67 }
 68 
 69 
 70 int main()
 71 {
 72     //freopen("../in.txt","r",stdin);
 73     scanf("%d",&T);
 74     while (T--)
 75     {
 76         scanf("%d%d%d",&nodenum,&edgenum,&hole);
 77         memset(edge,0,sizeof(edge));
 78         int i=0;
 79         int a,b,c;
 80         for (int j=1;j<=edgenum;j++)
 81         {
 82             scanf("%d%d%d",&a,&b,&c);
 83             i++;
 84             edge[i].u = a;
 85             edge[i].v = b;
 86             edge[i].cost = c;
 87             i++;
 88             edge[i].u = b;
 89             edge[i].v = a;
 90             edge[i].cost = c;
 91         }
 92         for (int j=1;j<=hole;j++)
 93         {
 94             scanf("%d%d%d",&a,&b,&c);
 95             i++;
 96             edge[i].u = a;
 97             edge[i].v = b;
 98             edge[i].cost = -c;
 99         }
100         edgenum = i;
101         if (Bellman_Ford())
102             printf("NO\n");
103         else
104             printf("YES\n");
105     }
106     return 0;
107 }