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

题目大意：农夫有F个农场，每个农场里有一些路径和虫洞，路径是双向的，虫洞是单向的，经过路径时会消耗t的时间，经过虫洞时时间会倒退x秒，求有没有可能使得农夫能在经过一些路径和虫洞之后看到之前的自己
思路：看到之前的自己就相当于是求图中有没有负环，对于虫洞我们将之权值修改为负数，在用一次SPFA即可

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, m, w;
struct node{
    int to, cost;
    node() {}
    node(int a, int b) :to(a), cost(b) {}
};
vector<node>e[505];
int dis[505], vis[505], f[505];
bool SPFA(int s)
{
    for (int i = 0; i <= n; i++) {
        dis[i] = INF;
        f[i] = 0; vis[i] = 0;
    }
    dis[s] = 0; f[s]++;
    vis[s] = 1; queue<int>Q;
    Q.push(s);
    while (!Q.empty()) {
        int t = Q.front(); Q.pop(); vis[t] = 0;
        for (int i = 0; i < e[t].size(); i++) {
            int tmp = e[t][i].to;
            if (dis[tmp] > dis[t] + e[t][i].cost) {
                dis[tmp] = dis[t] + e[t][i].cost;
                if (!vis[tmp]) {
                    vis[tmp] = 1;
                    Q.push(tmp);
                    if (++f[tmp] >= n)return false;
                }
            }
        }
    }
    return true;
}
int main()
{
    ios::sync_with_stdio(false);
    int T;
    cin >> T;
    while (T--) {
        for (int i = 1; i <= n; i++)e[i].clear();
        cin >> n >> m >> w;
        for (int a, b, c, i = 1; i <= m; i++) {
            cin >> a >> b >> c;
            e[a].push_back(node(b, c));
            e[b].push_back(node(a, c));
        }
        for (int a, b, c, i = 1; i <= w; i++) {
            cin >> a >> b >> c;
            e[a].push_back(node(b, -c));
        }
        if (!SPFA(1))cout << "YES" << endl;
        else cout << "NO" << endl;
    }
    return 0;
}