POJ3259 Wormholes（spfa判负环）

题意：农场主有N块地编号1到N，有M条路径连接这些边，每条边有一个花费的时间，还有W个单向的虫洞，穿越虫洞可以回到一定的时间之前（可看作负边）。问你这个农场主能否通过这些路径和虫洞遇到之前的自己。

思路：可以转化成求负环是否存在问题，只要存在负环，就可以无限更新时间，一定有解。SPFA板子即可。BFS版SPFA需要为每个点记录一个入队次数，如果有点入队超过定点数，一定存在负环。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <cmath>
#include <list>
#include <cstdlib>
#include <set>
#include <string>

using namespace std;

typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn = 505;
struct edg{
    int v, w, nxt;
}G[5501];
int head[maxn], tot;
void add(int u, int v, int w) {
    G[tot].v = v;
    G[tot].w = w;
    G[tot].nxt = head[u];
    head[u] = tot++;
}
int n, m, p;
bool spfa(int s) {
    int d[maxn], num[maxn];
    bool vis[maxn];
    memset(d, 0x3f, sizeof(d));
    memset(num, 0, sizeof(num));
    memset(vis, 0, sizeof(vis));
    queue<int> q;
    d[s] = 0;
    vis[s] = true;
    ++num[s];
    q.push(s);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        vis[u] = false;
        for (int i = head[u]; ~i; i = G[i].nxt) {
            int v = G[i].v, w = G[i].w;
            if (d[u] + w < d[v]) {
                d[v] = d[u] + w;
                if (!vis[v]) {
                    ++num[v];
                    if (num[v] > n) {
                        return true;
                    }
                    vis[v] = true;
                    q.push(v);
                }
            }
        }
    }
    return false;
}
int main() {
    int u, v, w, t;
    scanf("%d", &t);
    while (t--) {
        memset(head, -1, sizeof(head));
        tot = 0;
        scanf("%d%d%d", &n, &m, &p);
        while (m--) {
            scanf("%d%d%d", &u, &v, &w);
            add(u, v, w);
            add(v, u, w);
        }
        while (p--) {
            scanf("%d%d%d", &u, &v, &w);
            add(u, v, -w);
        }
        puts(spfa(1) ? "YES" : "NO");
    }
    return 0;
}