N - Wormholes(Bellman_ford && spfa)

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.

1. spfa

#include <cstdio>
#include <algorithm>
#include <queue>
#include <cstring>
using namespace std;
int const inf = 0x3f3f3f3f;
int G[505][505];
int vis[505], d[505], cont[505];
int n;
int spfa(int v){
    int i;
    memset(vis, 0, sizeof(vis));
    memset(cont, 0, sizeof(cont));
    memset(d, inf, sizeof(d));
    vis[v] = 1;
    d[v] = 0;
    cont[v]++;
    queue<int> Q;
    Q.push(v);
    while(!Q.empty()){
        v= Q.front();
        Q.pop();
        vis[v] = 0;
        for(i = 1; i <= n; i++){
            if(G[v][i] != inf && d[i] > d[v] +G[v][i]){
                d[i] = d[v] +G[v][i];
                if(!vis[i]){
                    cont[i]++;
                    Q.push(i);
                    vis[i] = 1;
                    if(cont[i] >= n-1)
                        return 1;
                }
            }
        }
    }
    return 0;
}
int main(){
    int F,a, b, c, m, w;
    int i, j;
    scanf("%d", &F);
    while(F--){
        scanf("%d%d%d", &n,&m, &w);
        memset(G, inf, sizeof(G));
        for(i = 1; i <= m; i++){
            scanf("%d%d%d", &a, &b, &c);
            if(c < G[a][b])
            G[a][b] =G[b][a] = c;
        }
        for(j = 0; j < w; j++){
            scanf("%d%d%d", &a, &b, &c);
          G[a][b] = -c;
        }
        if(spfa(1))
            printf("YES\n");
        else
            printf("NO\n");

    }
    return 0;
}

2.Bellman_Ford

#include <cstdio>
struct node{
    int u, v;
    int w;
}p[6005];
int const inf = 0x3f3f3f3f;
int n, m, w;
int num;
int Bellman_Ford(){
    int d[6005];
    int i, j;

    for(i = 1; i <= n; i++)
        d[i] = inf;
    d[1] = 0;
    for(i = 1; i <= n; i++){
        int flag = 0;
        for(j = 1; j <= num; j++) {
        if(d[p[j].v] > d[p[j].u] + p[j].w){
            d[p[j].v] = d[p[j].u] + p[j].w;
            flag = 1;
        }
    }
        if(!flag)
            return 0;
    }
    for(j = 1; j <= num; j++)
    {
        if(d[p[j].v] > d[p[j].u] + p[j].w)
            return 1;
    }
    return 0;
}
int main(){
    int F,a, b, c;
    int i, j;
    scanf("%d", &F);
    while(F--){
        scanf("%d%d%d", &n,&m, &w);
        num = 1;
        for(i = 1; i <= m; i++){
            scanf("%d%d%d", &a, &b, &c);
           p[num].u = a; p[num].v = b; p[num].w = c;
           num++;
           p[num].u = b; p[num].v = a; p[num].w = c;
           num++;
        }
        for(j = 0; j < w; j++){
            scanf("%d%d%d", &a, &b, &c);
            p[num].u = a; p[num].v = b; p[num].w = -c;
            num++;
        }
        num--;
        if(Bellman_Ford())
            printf("YES\n");
        else
            printf("NO\n");

    }
    return 0;
}