最短路 dijkstra and floyd
二：最短路算法分析报告
背景
最短路问题（short-path problem）：若网络中的每条边都有一个数值（长度、成本、时间等），则找出两节点（通常是源节点和阱节点）之间总权和最小的路径就是最短路问题。最短路问题是网络理论解决的典型问题之一，可用来解决管路铺设、线路安装、厂区布局和设备更新等实际问题。
单源最短路径
包括确定起点的最短路径问题，确定终点的最短路径问题（与确定起点的问题相反，该问题是已知终结结点，求最短路径的问题。在无向图中该问题与确定起点的问题完全等同，在有向图中该问题等同于把所有路径方向反转的确定起点的问题。） 。
求解单源最短路径问题可以采用Dijkstra算法，时间复杂度为O(|V|^2)。Dijkstra算法可以使用斐波那契堆、配对堆等支持Decrease-Key操作的数据结构来进一步优化，优化后的时间复杂度为O(|E|+|V|log|V|)。
Dijkstra只可求无负权的最短路径，因为其目光短浅，看不到后面可以消减的量。在正数中容易得证，若a<b，Dijkstra会取a，若再有一条路c，a+c<b+c是正确的。但引入负数后，可能会出现以下情况
，Dijkstra会先选择A-B这条边，此时A->B的距离固定为1，不再改变，但其实A->B最短路是-1，虽然A->C的最短路是正确的，为-2，但这样的算法是不可使用的。
如果图中有负权回路，可以采用Bellman-Ford算法，算法复杂度是O(|V||E|)。但Bellman-ford算法浪费了许多时间做无必要的松弛，可用SPFA算法进行优化，SPFA算法是用队列进行的优化，优化后时间复杂度为O(k|E|)， 其中k为所有顶点进队的平均次数，可以证明k一般小于等于2，由此可见该优化的效果十分显著。
全局最短路径
求图中所有的最短路径可以采用Floyd-Warshall算法，算法时间复杂度为O(|V|^3)。对于稀疏图，还可采用Johnson算法，其采用Bellman-ford和Dijkstra作为其子函数，时间复杂度为O（VElgV）。二者都可计算含负权路径的图，但不可含有负环。
两点最短路径
即已知起点和终点，求两结点之间的最短路径。通常可以用广度优先搜索（BFS）、深度优先搜索（DFS）等方式来实现，时间复杂度是O(|V|)。
本篇报告分析dijkstra算法和floyd算法。
问题描述
在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？
基本要求
输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，每行包括3个整数A，B，C（1<=A,B<=N,1<=C<=1000）,表示在路口A与路口B之间有一条路，我们的工作人员需要C分钟的时间走过这条路。输入保证至少存在1条商店到赛场的路线。
测试数据
输入
6 10
1 2 2
1 3 5
1 4 1
2 3 3
2 4 2
3 4 3
3 5 1
3 6 5
4 5 1
5 6 2
0 0
输出
4
算法思想
一：dijkstra
设G=(V,E)是一个带权有向图，把图中顶点集合V分成两组，第一组为已求出最短路径的顶点集合(用S表示，初始时S中只有一个源点，以后每求得一条最短路径 , 就将 加入到集合S中，直到全部顶点都加入到S中，算法就结束了)，第二组为其余未确定最短路径的顶点集合(用U表示)，按最短路径长度的递增次序依次把第二组的顶点加入S中。
在加入的过程中，总保持从源点v到S中各顶点的最短路径长度不大于从源点v到U中任何顶点的最短路径长度。此外，每个顶点对应一个距离，S中的顶点的距离就是从v到此顶点的最短路径长度，U中的顶点的距离是从v到此顶点只包括S中的顶点为中间顶点的当前最短路径长度。
二：floyd
（1）初始时设置一个n阶方阵，令其对角线元素为0，若存在弧<Vi,Vj>，则对应元素为权值，否则为。
（2）逐步试着在原直接路径中增加中间顶点，若加入中间点后路径变短，则修改之；否则，维持原值。
（3）所有顶点试探完毕，算法结束。
实现过程
一：dijkstra
|
终点 |
从V1到各终点的最短路径及长度 |
|||||
|
V2 |
2 <V1,V2> |
2 <V1,V2> |
------- |
------ |
-------- |
------- |
|
V3 |
5 <V1,V3> |
4 <V1,V4,V3> |
4 <V1,V4,V3> |
3 <V1,V4,V5,V3> |
------- |
--------- |
|
V4 |
1 <V1,V4> |
---------- |
------- |
-------- |
------- |
--------- |
|
V5 |
INF |
2 <V1,V4,V5> |
2 <V1,V4,V5> |
--------- |
------ |
-------- |
|
V6 |
INF |
INF |
INF |
4 <V1,V4,V5,V6> |
4 <V1,V4,V5,V6> |
-------- |
|
|
V4:1 <V1,V4> |
V2:2 <V1,V2> |
V5:2 <V1,V4,V5> |
V3:3 <V1,V4,V5,V3> |
V6:4 <V1,V4,V5,V6> |
|
图用带权邻接矩阵存储map[][]
数组dis[]存放当前找到的从源点V0到每个终点的最短路径长度，其初态为图中直接路径权值。
数组vis[]表示从是否访问过此点。
二：floyd
逐步试着在原直接路径中增加中间顶点，若加入中间点后路径变短，则修改之；否则，维持原值。
初始
|
|
1 |
2 |
3 |
4 |
5 |
6 |
|
1 |
0 |
2 |
5 |
1 |
INF |
INF |
|
2 |
2 |
0 |
3 |
2 |
INF |
INF |
|
3 |
5 |
3 |
0 |
3 |
1 |
5 |
|
4 |
1 |
2 |
3 |
0 |
1 |
INF |
|
5 |
INF |
INF |
1 |
1 |
0 |
2 |
|
6 |
INF |
INF |
5 |
INF |
2 |
0 |
加入1
|
|
1 |
2 |
3 |
4 |
5 |
6 |
|
1 |
0 |
2 |
5 |
1 |
INF |
INF |
|
2 |
|
0 |
3 |
2 |
INF |
INF |
|
3 |
|
|
0 |
3 |
1 |
5 |
|
4 |
|
|
|
0 |
1 |
INF |
|
5 |
|
|
|
|
0 |
2 |
|
6 |
|
|
|
|
|
0 |
加入2
|
|
1 |
2 |
3 |
4 |
5 |
6 |
|
1 |
0 |
2 |
5 |
1 |
INF |
INF |
|
2 |
|
0 |
5 |
2 |
INF |
INF |
|
3 |
|
|
0 |
3 |
1 |
5 |
|
4 |
|
|
|
0 |
1 |
INF |
|
5 |
|
|
|
|
0 |
2 |
|
6 |
|
|
|
|
|
0 |
加入3
|
|
1 |
2 |
3 |
4 |
5 |
6 |
|
1 |
0 |
2 |
5 |
1 |
INF |
10 |
|
2 |
|
0 |
5 |
2 |
4 |
8 |
|
3 |
|
|
0 |
3 |
1 |
5 |
|
4 |
|
|
|
0 |
1 |
8 |
|
5 |
|
|
|
|
0 |
2 |
|
6 |
|
|
|
|
|
0 |
加入4
|
|
1 |
2 |
3 |
4 |
5 |
6 |
|
1 |
0 |
2 |
4 |
1 |
2 |
9 |
|
2 |
|
0 |
3 |
2 |
3 |
8 |
|
3 |
|
|
0 |
3 |
1 |
5 |
|
4 |
|
|
|
0 |
1 |
8 |
|
5 |
|
|
|
|
0 |
2 |
|
6 |
|
|
|
|
|
0 |
加入5
|
|
1 |
2 |
3 |
4 |
5 |
6 |
|
1 |
0 |
2 |
3 |
1 |
2 |
4 |
|
2 |
|
0 |
3 |
2 |
3 |
5 |
|
3 |
|
|
0 |
2 |
1 |
3 |
|
4 |
|
|
|
0 |
1 |
3 |
|
5 |
|
|
|
|
0 |
2 |
|
6 |
|
|
|
|
|
0 |
代码实现
一：dijkstra
1 #include<stdio.h> 2 #include<string.h> 3 #include<iostream> 4 #include<algorithm> 5 using namespace std; 6 #define INF 0xfffffff 7 int pri[1010][1010];//两个顶点之间距离 8 int dis[1010];//起点到该点的最短距离 9 int vis[1010];//标记数组 10 int n,m; 11 12 void dijkstra() 13 { 14 memset(vis,0,sizeof(vis)); 15 vis[1]=1; 16 for(int i=2;i<=n;i++) 17 dis[i]=pri[1][i]; 18 for(int i=0;i<n;i++) 19 { 20 int M=INF,k=-1; 21 //每次找出最小的距离加入到集合 22 for(int j=1;j<=n;j++) 23 { 24 if(!vis[j]&&dis[j]<M) 25 M=dis[j],k=j; 26 } 27 if(k==-1) 28 return ; 29 vis[k]=1;//加入集合 30 //新加入一个顶点，更新到达各个顶点的距离 31 for(int j=1;j<=n;j++) 32 if(!vis[j]&&dis[j]>dis[k]+pri[k][j]) 33 dis[j]=dis[k]+pri[k][j]; 34 } 35 } 36 int main() 37 { 38 while(scanf("%d%d",&n,&m)!=EOF,n||m) 39 { 40 //初始化 41 for(int i=1;i<=n;i++) 42 for(int j=1;j<=n;j++) 43 pri[i][j]=i==j?0:INF; 44 for(int i=1;i<=m;i++) 45 { 46 int a,b,c;scanf("%d%d%d",&a,&b,&c); 47 if(pri[a][b]>c)//防止重边 48 pri[a][b]=pri[b][a]=c;//这个是无向图的存储 49 } 50 dijkstra(); 51 printf("%d\n",dis[n]); 52 } 53 return 0; 54 }
二：floyd
1 #include<stdio.h> 2 3 #include<string.h> 4 5 #include<iostream> 6 7 #include<algorithm> 8 9 using namespace std; 10 11 #define INF 0xfffffff 12 13 int pri[1010][1010];//两个顶点之间距离 14 15 int dis[1010];//起点到该点的最短距离 16 17 int vis[1010];//标记数组 18 19 int n,m; 20 21 void floyd() 22 23 { 24 25 for(int k=1;k<=n;k++)//中间点 26 27 { 28 29 for(int i=1;i<=n;i++) 30 31 { 32 33 for(int j=1;j<=n;j++) 34 35 { 36 37 pri[i][j]=min(pri[i][j],pri[i][k]+pri[k][j]);//取当前最短距离和含有中间顶点的距离的最小值 38 39 } 40 41 } 42 43 } 44 45 } 46 47 48 49 50 51 int main() 52 53 { 54 55 while(scanf("%d%d",&n,&m)!=EOF,n||m) 56 57 { 58 59 //初始化 60 61 for(int i=1;i<=n;i++) 62 63 for(int j=1;j<=n;j++) 64 65 pri[i][j]=i==j?0:INF; 66 67 for(int i=1;i<=m;i++) 68 69 { 70 71 int a,b,c;scanf("%d%d%d",&a,&b,&c); 72 73 if(pri[a][b]>c)//防止重边 74 75 pri[a][b]=pri[b][a]=c;//这个是无向图的存储 76 77 } 78 79 80 81 floyd(); 82 83 int a,b; 84 85 scanf("%d%d",&a,&b); 86 87 printf("%d\n",pri[a][b]); 88 89 90 91 } 92 93 return 0; 94 95 }
运行截图
一：dijkstra
二：floyd
个人总结
Dijkstra算法的时间复杂度为O(n^2) ,较之Floyd算法有很大提升，但是由于使用的是邻接矩阵的存储，所以说当顶点数过大的时候，我们就不可能用二维数组来存储了。切记每次加入一个点时要更新最短距离。Floyd算法的时间复杂度为（n^3），虽然代码简单但当n很大时会超时。
