POJ 3259 Wormholes spfa判负环

题目：

http://poj.org/problem?id=3259

题意：

有n个点，有m条双向边，走过每条边都要花费一个时间，还有w个虫洞，虫洞是单向的，通过虫洞会发生时光倒流，倒流一定的时间，问能不能发现一条路径，回到最初出发的时间之前

思路：

我们把边上花费的时间是正的，通过虫洞花费的时间倒流所以是负的，于是本题的实质就是判断图上有没有一个负环，那么用spfa判断有没有点入队超过n次，若有则存在负环，用等于n次判断是不对的，比如只有一个点

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <set>
#include <climits>
#include <cmath>
#include <queue>

using namespace std;

const int N = 510, INF = 0x3f3f3f3f, MOD = 100000000;

struct edge
{
    int to, cost, next;
}g[N*N*2];

int cnt, head[N];
int dis[N], num[N];
bool vis[N];
inline void add_edge(int v, int u, int cost)
{
    g[cnt].to = u, g[cnt].cost = cost, g[cnt].next = head[v], head[v] = cnt++;
}
bool spfa(int s, int t)
{
    queue<int> que;
    memset(dis, 0x3f, sizeof dis);
    memset(num, 0, sizeof num);
    memset(vis, 0, sizeof vis);
    que.push(s), dis[s] = 0, vis[s] = true, num[s]++;
    while(! que.empty())
    {
        int v = que.front(); que.pop();
        vis[v] = false;
        for(int i = head[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(dis[u] > dis[v] + g[i].cost)
            {
                dis[u] = dis[v] + g[i].cost;
                if(! vis[u])
                {
                    que.push(u), vis[u] = true, num[u]++;
                    if(num[u] > t) return true;//入队次数超过点数，存在负环
                }
            }
        }
    }
    return false;
}

int main()
{
    int t, n, m, k;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d%d", &n, &m, &k);
        cnt = 0;
        memset(head, -1, sizeof head);
        int v, u, cost;
        for(int i = 0; i < m; i++)
        {
            scanf("%d%d%d", &v, &u, &cost);
            add_edge(v, u, cost), add_edge(u, v, cost);
        }
        for(int i = 0; i < k; i++)
        {
            scanf("%d%d%d", &v, &u, &cost);
            add_edge(v, u, -cost);
        }
        if(spfa(1, n)) printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}