poj-3259 Wormholes（无向、负权、最短路之负环判断）

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

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

Sample Output

NO
YES

Hint

For farm 1, FJ cannot travel back in time. 
For farm 2, FJ could travel back in time by the cycle 1->2->3->1, arriving back at his starting location 1 second before he leaves. He could start from anywhere on the cycle to accomplish this.

 

题目大意：

时空旅行，前m条路是双向的，旅行时间为正值，w条路是虫洞，单向的，旅行时间是负值，也就是能回到过去。求从一点出发，判断能否在”过去“回到出发点，即会到出发点的时间是负的。

解题思路：

裸的负权最短路问题，SPFA Bellman-Ford解决。

 #include<iostream>
 #include<cstdio>
 using namespace std;
 #define INF 0x3f3f3f3f
 #define N 10100
 int nodenum, edgenum, w, original=; //点，边，起点

 typedef struct Edge //边
 {
     int u;
     int v;
     int cost;
 }Edge;//边的数据结构

 Edge edge[N];//边

 int dis[N];//距离

 bool Bellman_Ford()
 {
     for(int i = ; i <= nodenum; ++i) //初始化
         dis[i] = (i == original ?  : INF);
     int F=;
     for(int i = ; i <= nodenum - ; ++i)//进行nodenum-1次的松弛遍历
     {
         for(int j = ; j <= edgenum*+w; ++j)
         {
             if(dis[edge[j].v] > dis[edge[j].u] + edge[j].cost) //松弛（顺序一定不能反~）
             {
                 dis[edge[j].v] = dis[edge[j].u] + edge[j].cost;
                 F=;
             }
         }
         if(!F)
             break;
     }
         //与迪杰斯特拉算法类似，但不是贪心！
         //并没有标记数组
         //本来松弛已经结束了
         //但是因为由于负权环的无限松弛性
         bool flag = ; //判断是否含有负权回路
         //如果存在负权环的话一定能够继续松弛
         for(int i = ; i <= edgenum*+w; ++i)
         {
             if(dis[edge[i].v] > dis[edge[i].u] + edge[i].cost)
             {
                 flag = ;
                 break;
             }
         }
         //只有在负权环中才能再松弛下去
     return flag;
 }

 int main()
 {
     int t;
     scanf("%d",&t);
     while(t--)
     {

         scanf("%d %d %d", &nodenum, &edgenum, &w);

         for(int i = ; i <= *edgenum; i+=)//加上道路，双向边
         {
             scanf("%d %d %d", &edge[i].u, &edge[i].v, &edge[i].cost);
             edge[i+].u=edge[i].v;
             edge[i+].v=edge[i].u;
             edge[i+].cost=edge[i].cost;
         }
         for(int i =*edgenum+; i <= *edgenum+w; i++)//加上虫洞，单向边，负权
         {
             scanf("%d %d %d", &edge[i].u, &edge[i].v, &edge[i].cost);
             edge[i].cost=-edge[i].cost;
         }
         if(Bellman_Ford())//没有负环
             printf("NO\n");
         else
             printf("YES\n");
     }
     return ;
 }