Wormholes 最短路判断有无负权值

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.

 1 #include<stdio.h>
 2 #include<string.h>
 3 #include<stdlib.h>
 4 
 5 const int EM = 10000;
 6 const int VM = 600;
 7 const int INF = 999999;
 8 struct node
 9 {
10     int u,v,w;
11 }map[EM];
12 
13 int cnt,dis[VM];
14 int n,m,k;
15 
16 void addedge(int au,int av,int aw)
17 {
18     map[cnt].u = au;
19     map[cnt].v = av;
20     map[cnt].w = aw;
21     cnt++;
22 }
23 
24 int Bellman_ford()
25 {
26     int flag ,i;
27     //初始化
28     for( i = 1; i <= n; i++)
29     {
30         dis[i] = INF;
31     }
32     dis[1] =0;
33     
34     for( i = 1; i <= n; i++)
35     {
36         flag = 0;
37         for(int j = 0; j < cnt; j++)
38         {
39             if(dis[map[j].v] > dis[map[j].u]+map[j].w)
40             {
41                 dis[map[j].v] = dis[map[j].u]+map[j].w;
42                 flag = 1;
43             }
44         }
45         if(flag== 0) break;
46     }
47     if(i == n+1) return 1;//若第n次还可以松弛说明存在负环
48     else return 0;
49 }
50 
51 int main()
52 {
53     int t,u,v,w,ans;
54     scanf("%d",&t);
55     while(t--)
56     {
57         cnt = 0;
58         scanf("%d %d %d",&n,&m,&k);
59         while(m--)
60         {
61             scanf("%d %d %d",&u,&v,&w);
62             //添加双向边
63             addedge(u,v,w);
64             addedge(v,u,w);
65         }
66         while(k--)
67         {
68             scanf("%d %d %d",&u,&v,&w);
69             //添加单向边
70             addedge(u,v,-w);
71         }
72         ans = Bellman_ford();
73         if(ans == 1)
74             printf("YES\n");
75         else printf("NO\n");
76     }
77     return 0;
78 }

View Code

 1 //spfa判断有无负环
 2 #include<stdio.h>
 3 #include<string.h>
 4 #include<stdlib.h>
 5 #include<iostream>
 6 #include<queue>
 7 using namespace std;
 8 
 9 const int MAX = 510;
10 const int INF = 999999;
11 int n,m,w;
12 int map[MAX][MAX];
13 queue<int>que;
14 int inque[MAX];
15 int vexcnt[MAX];
16 int dis[MAX];
17 
18 bool spfa()
19 {
20     memset(inque,0,sizeof(inque));
21     memset(vexcnt,0,sizeof(vexcnt));
22     for(int i = 1; i <= n; i++)
23         dis[i] = INF;
24     dis[1] = 0;
25     que.push(1);
26     inque[1] = 1;
27     vexcnt[1]++;
28     while(!que.empty())
29     {
30         int tmp = que.front();
31         que.pop();
32         inque[tmp] = 0;
33         for(int i = 1; i <= n; i++)
34         {
35             if(dis[tmp] < INF && dis[i] > dis[tmp] + map[tmp][i])
36             {
37                 dis[i] = dis[tmp] + map[tmp][i];
38                 if(inque[i] == 0)
39                 {
40                     inque[i] = 1;
41                     vexcnt[i]++;
42                     que.push(i);
43                     if(vexcnt[i] >= n)
44                     {
45                         return false;
46                     }
47                 }
48             }
49         }
50     }
51     return true;
52 }
53 int main()
54 {
55     int t;
56     int x,y,z;
57     scanf("%d",&t);
58     while(t--)
59     {
60         while(!que.empty())que.pop();
61         scanf("%d %d %d",&n,&m,&w);
62         for(int i = 1; i <= n; i++)
63             for(int j = 1; j <= n; j++)
64             {
65                 if(i == j) map[i][j] = 0;
66                 else map[i][j] = INF;
67             }
68         for(int i = 1; i <= m; i++)
69         {
70             scanf("%d %d %d",&x,&y,&z);
71             if(map[x][y] > z)
72             {
73                 map[x][y] = z;
74                 map[y][x] = z;
75             }
76         }
77         for(int i = 1; i <= w; i++)
78         {
79             scanf("%d %d %d",&x,&y,&z);
80             if(map[x][y] > -z)
81                 map[x][y] = -z;
82         }
83         if(spfa())
84             printf("NO\n");
85         else printf("YES\n");
86     }
87     return 0;
88 }

View Code

<Bellman-Ford算法>

Dijkstra算法无法判断负权回路，而负权回路的含义是，回路的权值和为负。若不为负，即便有负权的边，也可正确求出最短路径，如果遇到负权，则可以采用Bellman-Ford算法。

Bellman-Ford算法能在更普遍的情况下（存在负权边）解决单源点最短路径问题。对于给定的带权（有向或无向）图 G=（V,E），其源点为s，加权函数 w是边集 E 的映射。对图G运行Bellman-Ford算法的结果是一个布尔值，表明图中是否存在着一个从源点s可达的负权回路。若不存在这样的回路，算法将给出从源点s到图G的任意顶点v的最短路径d[v]。

适用条件&范围

1.单源最短路径(从源点s到其它所有顶点v);

2.有向图&无向图(无向图可以看作(u,v),(v,u)同属于边集E的有向图);

3.边权可正可负(如有负权回路输出错误提示);

4.差分约束系统;

Bellman-Ford算法描述：

1,.初始化：将除源点外的所有顶点的最短距离估计值 d[v] ←+∞, d[s] ←0;

2.迭代求解：反复对边集E中的每条边进行松弛操作，使得顶点集V中的每个顶点v的最短距离估计值逐步逼近其最短距离；（运行|v|-1次）

3.检验负权回路：判断边集E中的每一条边的两个端点是否收敛。如果存在未收敛的顶点，则算法返回false，表明问题无解；否则算法返回true，并且从源点可达的顶点v的最短距离保存在 d[v]中。

描述性证明：

首先指出，图的任意一条最短路径既不能包含负权回路，也不会包含正权回路，因此它最多包含|v|-1条边。

其次，从源点s可达的所有顶点如果存在最短路径，则这些最短路径构成一个以s为根的最短路径树。Bellman-Ford算法的迭代松弛操作，实际上就是按顶点距离s的层次，逐层生成这棵最短路径树的过程。

在对每条边进行1遍松弛的时候，生成了从s出发，层次至多为1的那些树枝。也就是说，找到了与s至多有1条边相联的那些顶点的最短路径；对每条边进行第2遍松弛的时候，生成了第2层次的树枝，就是说找到了经过2条边相连的那些顶点的最短路径……。因为最短路径最多只包含|v|-1 条边，所以，只需要循环|v|-1 次。

每实施一次松弛操作，最短路径树上就会有一层顶点达到其最短距离，此后这层顶点的最短距离值就会一直保持不变，不再受后续松弛操作的影响。（但是，每次还要判断松弛，这里浪费了大量的时间，怎么优化？单纯的优化是否可行？）

注意：上述只对正权图有效。如果存在负权不一定第i次就能确定最短路，且与边的顺序有关。

如果没有负权回路，由于最短路径树的高度最多只能是|v|-1，所以最多经过|v|-1遍松弛操作后，所有从s可达的顶点必将求出最短距离。如果 d[v]仍保持 +∞，则表明从s到v不可达。

如果有负权回路，那么第 |v| 遍松弛操作仍然会成功，这时，负权回路上的顶点不会收敛。

posted on 2013-07-29 13:10 straw_berry 阅读(263) 评论(0) 编辑收藏举报