再看最短路算法 1 —— 单源最短路

学了多年的算法,最短路问题相当之常见————

好久没写过最短路的问题了,直到昨天闲的无聊来了一题——BZOJ3402(HansBug:额才发现我弱到只能刷水的地步了TT)

一看这不是明显的单源最短路么呵呵。。。于是直接上来来了个dijkstra,而且用的是邻接表存储图——

Submit之后,结果却是——

我立刻被雷到了QAQ。。。于是立刻改写spfa,结果——

4000ms+(估计还不止)和192ms究竟是怎样的差距啊QAQ,本人虽然早都听说过spfa的强大性,但是未曾想过差距会如此可怕,于是HansBug‘s Labo Online——

准备:1.dijkstra单源最短路径模板

 1 type
 2     point=^node;
 3     node=record
 4                g,w:longint;
 5                next:point;
 6     end;
 7
 8 var
 9    i,j,k,l,m,n:longint;
10    a:array[0..100000] of point;
11    b,c,lef,rig,fix:array[0..100000] of longint;
12    p:point;
13 procedure add(x,y,z:longint);inline;
14           var p:point;
15           begin
16                new(p);p^.g:=y;p^.w:=z;
17                p^.next:=a[x];a[x]:=p;
18           end;
19 function min(x,y:longint):longint;inline;
20          begin
21               if x<y then min:=x else min:=y;
22          end;
23 procedure swap(var x,y:longint);inline;
24         var z:longint;
25         begin
26                 z:=x;x:=y;y:=z;
27         end;
28 procedure merge(var x,y:longint);inline;
29         begin
30                 if x=0 then swap(x,y);
31                 if y=0 then exit;
32                 if b[x]>b[y] then swap(x,y);
33                 merge(rig[x],y);
34                 fix[x]:=min(fix[lef[x]],fix[rig[x]])+1;
35                 if fix[lef[x]]<fix[rig[x]] then swap(lef[x],rig[x]);
36         end;
37 function cuthead(var x:longint):longint;
38         begin
39                 c[x]:=1;
40                 cuthead:=b[x];
41                 merge(lef[x],rig[x]);
42                 x:=lef[x];
43         end;
44 procedure dijkstra(x:longint);inline;
45           var i,j,k,l:longint;p:point;
46           begin
47                fillchar(c,sizeof(c),0);
48                fillchar(b,sizeof(b),0);
49                c[x]:=1;
50                p:=a[x];
51                head:=0;l:=0;
52                while p<>nil do
53                      begin
54                           if b[p^.g]=0 then b[p^.g]:=p^.w else b[p^.g]:=min(b[p^.g],p^.w);
55                           p:=p^.next;
56                      end;
57                for i:=1 to n do
58                         if (c[i]=0) and (b[i]>0) then
59                                 begin
60                                         j:=i;
61                                         merge(head,j);
62                                 end;
63                for i:=1 to n-1 do
64                    begin
65                         if head=0 then break;
66                         p:=a[head];l:=cuthead(head);
67                         while p<>nil do
68                               begin
69                                    if (c[p^.g]=0) and ((b[p^.g]=0) or (b[p^.g]>(p^.w+l))) then b[p^.g]:=p^.w+l;
70                                    p:=p^.next;
71                               end;
72                    end;
73           end;
74 begin
75      readln(n,m);
76      for i:=1 to n do a[i]:=nil;
77      for i:=1 to m do
78          begin
79               readln(j,k,l);
80               add(j,k,l);
81          end;
82      dijkstra(1);
83      for i:=1 to n do
84          case c[i] of
85               1:writeln(1,‘ ---> ‘,i,‘ : ‘,b[i]);
86               0:writeln(1,‘ ---> ‘,i,‘ : ‘,‘Unavailable‘);
87          end;
88      readln;
89 end.

2.spfa单源最短路径模板

 1 type
 2         point=^node;
 3         node=record
 4                 g,w:longint;
 5                 next:point;
 6         end;
 7 var
 8         i,j,k,l,m,n:longint;
 9         a:array[0..100000] of point;
10         b,c:array[0..1000000] of longint;
11 procedure add(x,y,z:longint);inline;
12         var p:point;
13         begin
14                 new(p);p^.g:=y;p^.w:=z;
15                 p^.next:=a[x];a[x]:=p;
16         end;
17 procedure spfa(x:longint);inline;
18         var f,r:longint;p:point;
19         begin
20                 f:=1;r:=2;
21                 fillchar(c,sizeof(c),0);
22                 c[x]:=1;
23                 b[1]:=x;
24                 while f<r do
25                         begin
26                                 p:=a[b[f]];
27                                 while p<>nil do
28                                         begin
29                                                 if (c[p^.g]=0) or (c[p^.g]>(p^.w+c[b[f]])) then
30                                                         begin
31                                                                 c[p^.g]:=p^.w+c[b[f]];
32                                                                 b[r]:=p^.g;
33                                                                 inc(r);
34                                                         end;
35                                                 p:=p^.next;
36                                         end;
37                                 inc(f);
38                         end;
39                 for i:=1 to n do dec(c[i]);
40         end;
41 begin
42         readln(n,m);
43         for i:=1 to n do a[i]:=nil;
44         for i:=1 to m do
45                 begin
46                         readln(j,k);
47                         add(j,k,1);add(k,j,1);
48                 end;
49         spfa(1);
50         for i:=1 to n do
51                 case c[i] of
52                         -1:writeln(1,‘ ---> ‘,i,‘ : ‘,‘Unavailable‘);
53                         else writeln(1,‘ ---> ‘,i,‘ : ‘,c[i]);
54                 end;
55         readln;
56 end.

3.bat对拍小程序

(PS:由于Bellman-Ford算法具有超高的时空浪费量,还有Floyd一般不用于单源最短路,所以只准备这些)

还有:这次采用的对拍模式如下——模拟一般OI赛制上的10组数据,30%数据满足规模为N<=10000 M<=100000;60%的数据满足规模为N<=30000 M<=200000;100%的数据满足N<=50000 M<=1000000。每10组这样的数据为一组,多组测试

公布结果——在30%的数据时,spfa用时200ms多点,dijkstra用时300ms多点

在60%数据时,spfa用时400ms多点,dijkstra用时1500-1800ms

在100%数据时,dpfa用时1300ms+,dijkstra用时11000-14000ms

差距就是——10倍,尤其是数量上去之后

原因——dijkstra里面最怕的就是一边接着一遍的扫描最小值,而且事实证明,如果像我原来预想的样子写堆优化的话——1.堆优化难写,因为不仅仅涉及到删除和加入新值 2.代码量会成倍的扩大。也就是说真正的成了O(N^2).而spfa是与边的密度相关的,且减少了许多的松弛操作

总结:事实的效果才能说明一切。更何况这个里面是随机生成的数据而不是OI的时候有意构造出来的更加强的数据。。。

(附:用于对拍的batch)

 1 @echo off
 2 :2
 3 set /a s=0
 4 cls
 5 :1
 6 set /a s=s+1
 7 echo Test %s%
 8 if %s% leq 3 (
 9 echo 10000 100000|fuckpath.exe >path.in
10 goto 4)
11 if %s% leq 6 (
12 echo 30000 200000|fuckpath.exe >path.in
13 goto 4)
14 if %s% leq 10 (
15 echo 50000 1000000|fuckpath.exe >path.in
16 goto 4)
17 :4
18 echo.|time
19 type path.in|spfa.exe >spfa.out
20 echo.|time
21 echo.|time
22 type path.in|dijkstra.exe >dijkstra.out
23 echo.|time
24 fc dijkstra.out spfa.out
25 if %s%==10 (goto 3)
26 goto 1
27 :3
28 pause
29 goto 2
时间: 2024-10-03 23:15:30

再看最短路算法 1 —— 单源最短路的相关文章

用scheme语言实现SPFA算法(单源最短路)

最近自己陷入了很长时间的学习和思考之中,突然发现好久没有更新博文了,于是便想更新一篇. 这篇文章是我之前程序设计语言课作业中一段代码,用scheme语言实现单源最段路算法.当时的我,花了一整天时间,学习了scheme并实现了SPFA算法,那天实现之后感觉很有成就感-在这里贴出来,以飨读者. 突然发现博客园不支持scheme语言,于是只能放弃高亮了.不得不说,scheme代码有没有高亮差别好大…… ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; ;; 题目

hdu1874 畅通工程续(Dijkstra算法,单源最短路)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1874 畅通工程续 Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 36359    Accepted Submission(s): 13355 Problem Description 某省自从实行了很多年的畅通工程计划后,终于修建了很多路.

模板C++ 03图论算法 1最短路之单源最短路(SPFA)

3.1最短路之单源最短路(SPFA) 松弛:常听人说松弛,一直不懂,后来明白其实就是更新某点到源点最短距离. 邻接表:表示与一个点联通的所有路. 如果从一个点沿着某条路径出发,又回到了自己,而且所经过的边上的权和小于0, 就说这条路是一个负权回路. 回归正题,SPFA是bellman-ford的一种改进算法,由1994年西安交通大学段凡丁提出.它无法处理带有负环的图,判断方法:如果某个点进入队列的次数超过N次则存在负环. SPFA的两种写法,bfs和dfs,bfs判别负环不稳定,相当于限深度搜索

单源最短路 狄克斯特拉算法

一般形式的用邻接矩阵来实现dijkstra效率比较低,我这里直接记录的是用邻接表的方法以及用优先队列加以应用. 首先解释什么是dijkstra算法 dijkstra算法 dijkstra算法适用于求单源最短路,即可以求出起点到其余各点之间的最短路.它的算法实现是一个不断更新的过程. 举一个最简单的例子,假设有这么一个图,红色表示权值,黑色表示4个点以及路径,我们假设起点为1,用d[i]来表示1到i的最短路,那么在第一轮的时候,d[2]=1,d[3]=1,d[4]=5,再下一轮的时候会对这个情况进

【裸单源最短路:Dijkstra算法两种版本】hdu 1874 畅通工程续

Source : hdu 1874 畅通工程续 http://acm.hdu.edu.cn/showproblem.php?pid=1874 Problem Description 某省自从实行了很多年的畅通工程计划后,终于修建了很多路.不过路多了也不好,每次要从一个城镇到另一个城镇时,都有许多种道路方案可以选择,而某些方案要比另一些方案行走的距离要短很多.这让行人很困扰. 现在,已知起点和终点,请你计算出要从起点到终点,最短需要行走多少距离. Input 本题目包含多组数据,请处理到文件结束.

Dijkstra算法 --- 单源最短路

Dijkstra算法适用于边权值为正的情况,可用于计算正权图上的单元最短路. 其伪代码如下: 设d[v0] = 0, 其他d[i] = INF 循环n次{ 在所有未标号的结点中,选取d值最小的结点x 给结点x加上永久标号 对于从x出发的所有边,执行松弛操作. } //松弛操作的伪代码如下: RELAX(u,v,w) if(u.d + w(u,v) < v.d){ v.d = w.d + w(u,v); pre[v] = u; } Dijkstra算法代码: /* Dijkstra 单源最短路算法

利用无权图的单源最短路算法实现地铁换乘图

//Metro.php $MetroVertex = array( 1 => '体育中心', 2 => '体育西路', 3 => '杨箕', 4 => '东山口', 5 => '烈士陵园', 6 => '农讲所', 7 => '公园前', 8 => '西门口', 9 => '陈家祠', 10 => '长寿路', 11 => '黄沙', 12 => '芳村', 13 => '花地湾', 14 => '坑口', 15 =>

【算法系列学习】Dijkstra单源最短路 [kuangbin带你飞]专题四 最短路练习 A - Til the Cows Come Home

https://vjudge.net/contest/66569#problem/A http://blog.csdn.net/wangjian8006/article/details/7871889 邻接矩阵实现的单源最短路 1 #include<iostream> 2 #include<cstdio> 3 #include<string> 4 #include<cstring> 5 #include<algorithm> 6 #include

UVA 658 It&#39;s not a Bug, it&#39;s a Feature! (单源最短路,dijkstra+优先队列,变形,经典)

题意:有n个bug,有m个补丁,每个补丁有一定的要求(比如某个bug必须存在,某个必须不存在,某些无所谓等等),打完出来后bug还可能变多了呢.但是打补丁是需要时间的,每个补丁耗时不同,那么问题来了:要打多久才能无bug?(同1补丁可重复打) 分析: n<=20,那么用位来表示bug的话有220=100万多一点.不用建图了,图实在太大了,用位图又不好玩.那么直接用隐式图搜索(在任意点,只要满足转移条件,任何状态都能转). 但是有没有可能每个状态都要搜1次啊?那可能是100万*100万啊,这样出题