poj 3259 Wormholes

题目链接：

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

题目大意：

　　有一个穿越时光的农夫，他有N个农场，每个农场有M条双向路，有W个单向虫洞，每条路有三个属性（s，e，t）分别代表的是从s到达e花费t时间，每个虫洞也有三个属性（s，e，t）分别代表的是s到达e花费-t时间，这个农夫想要满足自己的穿越时光的梦想，他想在他的农场里游荡一圈以后回到原点并且看到原来的自己，如果能满足他的梦想就输出“YES”，否者“NO”。

解题思路：

　　可以看出这道题目就是判断所建图中有没有负权回路，用spfa就可以解决。

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <queue>
#include <cmath>
#include <iostream>
#include <algorithm>
using namespace std;
#define maxn 510
#define INF 0x3f3f3f3f

struct Edge
{
    int e, w;
    Edge(int e=0, int w=0) : e(e), w(w) {}
};

vector<Edge> G[maxn];
int dist[maxn], n;
void init ();
bool spfa ();

int main ()
{
    int f;
    scanf ("%d", &f);
    while (f --)
    {
        int m, w, i;
        init ();
        scanf ("%d %d %d", &n, &m, &w);

        for (i=0; i<m; i++)
        {
            int a, b, c;
            scanf("%d %d %d", &a, &b, &c);
            G[a].push_back (Edge (b, c));
            G[b].push_back (Edge (a, c));
        }

        for (i=0; i<w; i++)
        {
            int a, b, c;
            scanf ("%d %d %d", &a, &b, &c);
            G[a].push_back (Edge (b, -c));
        }
        if (spfa ())
            printf ("NO
");
        else
            printf ("YES
");
    }
    return 0;
}

void init ()
{
    for (int i=0; i<maxn; i++)
        dist[i] = INF, G[i].clear();
}

bool spfa ()
{
    int updata[maxn];
    queue<Edge>que;
    Edge pn;
    pn.e = 1, pn.w = 0;
    memset (updata, 0, sizeof(updata));

    que.push(pn);
    dist[1] = 0;
    updata[pn.e] = 1;
    while ( !que.empty())
    {
        pn = que.front();
        que.pop();
        int len = G[pn.e].size();

        for (int i=0; i<len; i++)
        {
            Edge p = G[pn.e][i];
            if (dist[p.e] > dist[pn.e] + p.w)
            {
                dist[p.e] = dist[pn.e] + p.w;
                    que.push(p);
                    updata[p.e] ++;
                    if (updata[p.e] == n)
                        return false;
            }
        }
    }
    return true;
}