Wormholes POJ3259 （spfa）

题目：http://poj.org/problem?id=3259

题目大意：F组数据， 输入n, m, w,表示n块田地， m个田与田之间的关系，w个虫洞，从一块田到达另一块田需要花一定时间， 穿过虫洞时时间会倒流，问是否能够回到出发前的时间

解题思路：判断是否存在负环，若存在则一定能够回去。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 3500;
int T, N, M, W;
struct Edge
{
    int to, w, nxt;
}edge[MAXN*2];

int head[MAXN], t;
int vis[MAXN], num[MAXN], dis[MAXN];

void init()
{
    memset(head, -1, sizeof(head)); t = 1;
    memset(vis, 0, sizeof(vis));
    memset(num, 0, sizeof(num));
    memset(dis, INF, sizeof(dis));
}
void addEdge(int u, int v, int w)
{
    edge[t].to = v;
    edge[t].w = w;
    edge[t].nxt = head[u];
    head[u] = t++;
}
bool spfa()
{
    queue<int> q;
    vis[1] = 1;  /// 是否经过该点
    dis[1] = 0;  /// 到达某个点花费的时间
    num[1] = 1;  /// 某个点经过了多少次

    q.push(1);  /// 编号为1的边进队
    while(!q.empty())
    {
        int u = q.front(); q.pop();
        vis[u] = 0;

        for(int i = head[u]; i != -1; i = edge[i].nxt)
        {
            int to = edge[i].to;
            if(dis[to] > dis[u] + edge[i].w)
            {
                dis[to] = dis[u] + edge[i].w;
                if(!vis[to])
                {
                    num[to]++;
                    if(num[to] >= N)  /// 有负环，一定能回去
                        return true;

                    vis[to] = 1;
                    q.push(to);
                }
            }
        }
    }
    return false ;
}

int main()
{
    scanf("%d", &T);
    while(T--)
    {
        init();
        scanf("%d %d %d", &N, &M, &W);
        int a, b, c;
        for(int i = 1; i <= M; i++)
        {
            scanf("%d %d %d", &a, &b, &c);
            addEdge(a, b, c);  /// 双向
            addEdge(b, a, c);
        }

        for(int i = 1; i <= W; i++)
        {
            scanf("%d %d %d", &a, &b, &c);
            addEdge(a, b, -c);
        }
        if(spfa())
            printf("YES\n");
        else
            printf("NO\n");
    }
    return 0;
}