F - Wormholes POJ - 3259-CSDN博客

本文链接：https://blog.csdn.net/qq_32193741/article/details/81258922

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

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.

题意是问是否能通过虫洞回到过去；

虫洞是一条单向路，不但会把你传送到目的地，而且时间会倒退Ts。

//注意路是双向的虫洞是单向的

我们把虫洞看成是一条负权路，问题就转化成求一个图中是否存在负权回路；

bellman_ford算法

Bellman-Ford算法流程分为三个阶段：

(1)初始化：将除源点外的所有顶点的最短距离估计值 d[v] ←+∞, d[s] ←0;

(2)迭代求解：反复对边集E中的每条边进行松弛操作，使得顶点集V中的每个顶点的最短距离估计值逐步逼近其最短距离；（运行|v|-1次）

(3)检验负权回路：判断边集E中的每一条边的两个端点是否收敛。如果存在未收敛的顶点，则算法返回false，表明问题无解；否则算法返回true，并且从源点可达的顶点

v的最短距离保存在 d[v]中

#include<iostream>
#include<cstring>
#define Maxn 5600
#define Maxe 1550
#define inf 1e8


using namespace std;
int u[Maxn], v[Maxn], e[Maxn];
int dis[Maxe];
int n, m, w;
int cnt;
int p;
int bellman(){
    for(int i = 1; i <= n; i++){
        dis[i] = inf;
    }
    dis[1] = 0;
    for(int i = 1; i < n; i++){
        int couts = 0;
        for(int k = 1; k < cnt; k++){
            if(dis[v[k]] > dis[u[k]] + e[k]){
                dis[v[k]] = dis[u[k]] + e[k];
                couts = 1;
            }
        }
        if(!couts)return 0;
    }
    for(int i = 1; i <= cnt; i++){
        if(dis[v[i]] > dis[u[i]] + e[i])return 1;
    }
    return 0;
}
int main(){
    int t;
    cin >> t;
    while(t--){
        cin >> n >> m >> w;
        cnt = 1;
        for(int i = 1; i <= m; i++){
            int x1, x2, x3;
            cin >> x1 >> x2 >> x3;
            u[cnt] = x1, v[cnt] = x2;
            e[cnt++] = x3;
            u[cnt] = x2, v[cnt] = x1;
            e[cnt++] = x3;
        }
        p = cnt;
        for(int i = 1; i <= w; i++){
            int x1, x2, x3;
            cin >> x1 >> x2 >> x3;
            u[cnt] = x1, v[cnt] = x2;
            e[cnt++] = -x3;
        }
        if(bellman())cout  << "YES" << endl;
        else cout << "NO" <<endl;
    }
    return 0;
}