poj3259 (spfa找负环)

Wormholes
Time Limit: 2000MS Memory Limit: 65536K
Total Submissions: 80990 Accepted: 30023
Description

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

John的农场里N块地，M条路连接两块地，W个虫洞，虫洞是一条单向路，会在你离开之前把你传送到目的地，就是当你过去的时候时间会倒退Ts。我们的任务是知道会不会在从某块地出发后又回来，看到了离开之前的自己。总的来说，就是看图中有没有负权环。有的话就是可以，没有的话就是不可以了。

#include <iostream>
#include <queue>
#include <vector>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
struct node
{
   int v, w;
   node(int v, int w) : v(v), w(w) {}
};
int n, m, s;
vector<node> adj[10005];
int vis[10005];
int time[10005];
int dis[10005];
bool spfa(int st)
{
   memset(dis, 0x3f, sizeof(dis));
   memset(vis, 0, sizeof(vis));
   memset(time, 0, sizeof(time));
   queue<int> q;
   dis[st] = 0;
   vis[st] = 1;
   time[st] = 1;
   q.push(st);
   while (!q.empty())
   {
      int u = q.front();
      q.pop();
      vis[u] = 0;
      for (int i = 0; i < adj[u].size(); i++)
      {
         int v = adj[u][i].v;
         int w = adj[u][i].w;
         if (dis[v] > dis[u] + w)
         {
            dis[v] = dis[u] + w;
            time[v]++;
            q.push(v);
            if (time[v] >= n)
               return true;
         }
      }
   }
   if (dis[st] < 0)
      return true;
   return false;
}
void solve()
{
   for (int i = 1; i <= n; i++)
   {
      if (spfa(i))
      {
         printf("YES\n");
         return;
      }
   }
   printf("NO\n");
}
int main()
{
   int t, a, b, c;
   scanf("%d", &t);
   while (t--)
   {
      for (int i = 0; i < 10005; i++)
      {
         adj[i].clear();
      }
      scanf("%d%d%d", &n, &m, &s);
      for (int i = 0; i < m; i++)
      {
         scanf("%d%d%d", &a, &b, &c);
         adj[a].push_back(node(b, c));
         adj[b].push_back(node(a, c));
      }
      for (int i = 0; i < s; i++)
      {
         scanf("%d%d%d", &a, &b, &c);
         adj[a].push_back(node(b, -c));
      }
      solve();
   }
   return 0;
}