Dijkstra

转自：http://blog.chinaunix.net/uid-26548237-id-3834514.html

Dijkstra（迪杰斯特拉）算法是典型的最短路径路由算法，用于计算一个节点到其他所有节点的最短路径。主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。Dijkstra算法能得出最短路径的最优解，但由于它遍历计算的节点很多，所以效率低。
    Dijkstra算法是很有代表性的最短路径算法，在很多专业课程中都作为基本内容有详细的介绍，比如数据结构、图论、运筹学等。
    
1、算法思想
    令G = （V，E）为一个带权有向图，把图中的顶点集合V分成两组，第一组为已求出最短路径的顶点集合S（初始时S中只有源节点，以后每求得一条最短路径，就将它对应的顶点加入到集合S中，直到全部顶点都加入到S中）；第二组是未确定最短路径的顶点集合U。在加入过程中，总保持从源节点v到S中各顶点的最短路径长度不大于从源节点v到U中任何顶点的最短路径长度。
 
2、算法步骤
    （1）初始化时，S只含有源节点；
    （2）从U中选取一个距离v最小的顶点k加入S中（该选定的距离就是v到k的最短路径长度）；
    （3）以k为新考虑的中间点，修改U中各顶点的距离；若从源节点v到顶点u的距离（经过顶点k）比原来距离（不经过顶点k）短，则修改顶点u的距离值，修改后的距离值是顶点k的距离加上k到u的距离；
    （4）重复步骤（2）和（3），直到所有顶点都包含在S中。
    具体图例与算法执行步骤：（就从A开始，到各节点的最短路径）。
     

    具体执行步骤如下图所示。
    

    PS：图片右下角是原作者的博客地址。
    
3、算法具体实现
     算法的具体实现如下所示。

1. #include “stdio.h” 
   
2. #include “stdlib.h” 
3. #include “io.h” 
4. #include “math.h” 
5. #include “time.h”
7. #define OK 1
8. #define ERROR 0
9. #define TRUE 1
10. #define FALSE 0
12. #define MAXEDgE 20
13. #define MAXVEX 20
14. #define INFINITY 65535
16. typedef int Status;    /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ 
19. typedef struct
20. {
21.     int vexs[MAXVEX];
22.     int arc[MAXVEX][MAXVEX];
23.     int numVertexes, numEdges;
24. }Mgraph;
26. typedef int Patharc[MAXVEX];            /* 用于存储最短路径下标的数组 */
27. typedef int ShortPathTable[MAXVEX];        /* 用于存储到各点最短路径的权值和 */
30. void CreateMgraph(Mgraph *g)
31. {
32.     int i, j;
34.     /* printf(“请输入边数和顶点数:”); */
35.     g–>numEdges=16;
36.     g–>numVertexes=9;
38.     for (i = 0; i < g–>numVertexes; i++)/* 初始化图 */
39.     {
40.         g–>vexs[i]=i;
41.     }
43.     for (i = 0; i < g–>numVertexes; i++)/* 初始化图 */
44.     {
45.         for ( j = 0; j < g–>numVertexes; j++)
46.         {
47.             if (i==j)
48.                 g–>arc[i][j]=0;
49.             else
50.                 g–>arc[i][j] = g–>arc[j][i] = INFINITY;
51.         }
52.     }
54.     g–>arc[0][1]=1;
55.     g–>arc[0][2]=5; 
56.     g–>arc[1][2]=3; 
57.     g–>arc[1][3]=7; 
58.     g–>arc[1][4]=5; 
60.     g–>arc[2][4]=1; 
61.     g–>arc[2][5]=7; 
62.     g–>arc[3][4]=2; 
63.     g–>arc[3][6]=3; 
64.     g–>arc[4][5]=3;
66.     g–>arc[4][6]=6;
67.     g–>arc[4][7]=9; 
68.     g–>arc[5][7]=5; 
69.     g–>arc[6][7]=2; 
70.     g–>arc[6][8]=7;
72.     g–>arc[7][8]=4;
75.     for(i = 0; i < g–>numVertexes; i++)
76.     {
77.         for(j = i; j < g–>numVertexes; j++)
78.         {
79.             g–>arc[j][i] =g–>arc[i][j];
80.         }
81.     }
83. }
85. /* Dijkstra算法，求有向网g的v0顶点到其余顶点v的最短路径P[v]及带权长度D[v] */ 
86. /* P[v]的值为前驱顶点下标,D[v]表示v0到v的最短路径长度和 */ 
87. void ShortestPath_Dijkstra(Mgraph g, int v0, Patharc *P, ShortPathTable *D)
88. { 
89.     int v,w,k,min; 
90.     int final[MAXVEX];                    /* final[w]=1表示求得顶点v0至vw的最短路径 */
91.     
92.     /* 初始化数据 */
93.     for(v=0; v<g.numVertexes; v++)        
94.     { 
95.         final[v] = 0;                    /* 全部顶点初始化为未知最短路径状态 */
96.         (*D)[v] = g.arc[v0][v];            /* 将与v0点有连线的顶点加上权值 */
97.         (*P)[v] = 0;                    /* 初始化路径数组P为0 */ 
98.     }
100.     (*D)[v0] = 0;                        /* v0至v0路径为0 */ 
101.     final[v0] = 1;                        /* v0至v0不需要求路径 */ 
102.     
103.     /* 开始主循环，每次求得v0到某个v顶点的最短路径 */ 
104.     for(v=1; v<g.numVertexes; v++) 
105.     {
106.         min=INFINITY;                    /* 当前所知离v0顶点的最近距离 */ 
107.         for(w=0; w<g.numVertexes; w++) /* 寻找离v0最近的顶点 */ 
108.         { 
109.             if(!final[w] && (*D)[w]<min) 
110.             { 
111.                 k=w; 
112.                 min = (*D)[w];            /* w顶点离v0顶点更近 */ 
113.             } 
114.         } 
115.         final[k] = 1;                    /* 将目前找到的最近的顶点置为1 */
117.         /* 修正当前最短路径及距离 */
118.         for(w=0; w<g.numVertexes; w++) 
119.         {
120.             /* 如果经过v顶点的路径比现在这条路径的长度短的话 */
121.             if(!final[w] && (min+g.arc[k][w]<(*D)[w])) 
122.             { 
123.                 /* 说明找到了更短的路径，修改D[w]和P[w] */
124.                 (*D)[w] = min + g.arc[k][w]; /* 修改当前路径长度 */ 
125.                 (*P)[w]=k; 
126.             } 
127.         } 
128.     }
129. }
131. int main(void)
132. { 
133.     int i,j,v0;
134.     Mgraph g; 
135.     Patharc P; 
136.     ShortPathTable D; /* 求某点到其余各点的最短路径 */ 
137.     v0=0;
138.     
139.     CreateMgraph(&g);
140.     
141.     ShortestPath_Dijkstra(g, v0, &P, &D); 
143.     printf(“最短路径倒序如下:\n”); 
144.     for(i=1;i<g.numVertexes;++i) 
145.     { 
146.         printf(“v%d – v%d : “,v0,i);
147.         j=i;
148.         while(P[j]!=0)
149.         {
150.             printf(“%d “,P[j]);
151.             j=P[j];
152.         }
153.         printf(“\n”);
154.     } 
155.     printf(“\n源点到各顶点的最短路径长度为:\n”); 
156.     for(i=1;i<g.numVertexes;++i) 
157.         printf(“v%d – v%d : %d \n”,g.vexs[0],g.vexs[i],D[i]); 
158.     return 0;
159. }

Floyd

转自：http://blog.chinaunix.net/uid-26548237-id-3834873.html   

上面我们通过迪杰斯特拉算法解决了从某个源点到其余各顶点的最短路径问题。从循环嵌套很容易得到此算法的时间复杂度为O(n^2)。可是怎么只找到从源点到某一个特定终点的最短路径，其实这个问题和求源点到其他所有顶点的最短路径一样复杂，时间复杂度依然是O(n^2)。
    此时比较简单方法就是对每个顶点当作源点运行一次迪杰斯特拉算法，等于在原有算法的基础上，再来一次循环，此时整个算法的时间复杂度为O(n^3)。
    对此，我们再来学习另一个求最短路径的算法——弗洛伊德（Floyd），它求所有顶点到所有顶点的最短路径，时间复杂度也为O(n^3)，但其算法非常简洁优雅。
    
    为了能讲明白该算法的精妙所在，先来看最简单的案例。下图左部分是一个最简单的3个顶点连通网图。
    

    先定义两个数组D[3][3]和P[3][3]，D代表顶点到顶点的最短路径权值和的矩阵，P代表对应顶点的最小路径的前驱矩阵。在未分析任何顶点之前，我们将D命名为D^-1  ，其实它就是初始的图的邻接矩阵。将P命名为P^-1 ，初始化为图中所示的矩阵。
    首先，我们来分析，所有的顶点经过v0后到达另一顶点的最短距离。因为只有三个顶点，因此需要查看v1->v0->v2，得到D^-1 [1][0] + D^-1 [0][2] = 2 + 1 = 3。D^-1 [1][2]表示的是v1->v2的权值是5，我们发现D^-1 [1][2] > D^-1 [1][0] + D^-1 [0][2]，通俗的讲就是v1->v0->v2比直接v1->v2距离还要近。所以我们就让D^-1 [1][2]  = D^-1 [1][0] + D^-1 [0][2]，同样的D^-1 [2][1]  = 3，于是就有了D⁰ 的矩阵。因为有了变化，所以P矩阵对应的P^-1[1][2]和P^-1[2][1]也修改为当前中转的顶点v0的下标0，于是就有了P⁰。也就是说：
    —>动态规划乎
    接下来，其实也就是在D⁰和P⁰的基础上，继续处理所有顶点经过v1和v2后到达另一顶点的最短路径，得到D¹和P¹、D²和P²完成所有顶点到所有顶点的最短路径的计算。
    首先我们针对下图的左网图准备两个矩阵D^-1和P^-1，就是网图的邻接矩阵，初设为P[j][j] = j这样的矩阵，它主要用来存储路径。
    
    具体代码如下，注意是：求所有顶点到所有顶点的最短路径，因此Pathmatirx和ShortPathTable都是二维数组。

    此时比较简单方法就是对每个顶点当作源点运行一次迪杰斯特拉算法，等于在原有算法的基础上，再来一次循环，此时整个算法的时间复杂度为O(n^3)。
    对此，我们再来学习另一个求最短路径的算法——弗洛伊德（Floyd），它求所有顶点到所有顶点的最短路径，时间复杂度也为O(n^3)，但其算法非常简洁优雅。
    
    为了能讲明白该算法的精妙所在，先来看最简单的案例。下图左部分是一个最简单的3个顶点连通网图。
    

    先定义两个数组D[3][3]和P[3][3]，D代表顶点到顶点的最短路径权值和的矩阵，P代表对应顶点的最小路径的前驱矩阵。在未分析任何顶点之前，我们将D命名为D^-1  ，其实它就是初始的图的邻接矩阵。将P命名为P^-1 ，初始化为图中所示的矩阵。
    首先，我们来分析，所有的顶点经过v0后到达另一顶点的最短距离。因为只有三个顶点，因此需要查看v1->v0->v2，得到D^-1 [1][0] + D^-1 [0][2] = 2 + 1 = 3。D^-1 [1][2]表示的是v1->v2的权值是5，我们发现D^-1 [1][2] > D^-1 [1][0] + D^-1 [0][2]，通俗的讲就是v1->v0->v2比直接v1->v2距离还要近。所以我们就让D^-1 [1][2]  = D^-1 [1][0] + D^-1 [0][2]，同样的D^-1 [2][1]  = 3，于是就有了D⁰ 的矩阵。因为有了变化，所以P矩阵对应的P^-1[1][2]和P^-1[2][1]也修改为当前中转的顶点v0的下标0，于是就有了P⁰。也就是说：
    —>动态规划乎
    接下来，其实也就是在D⁰和P⁰的基础上，继续处理所有顶点经过v1和v2后到达另一顶点的最短路径，得到D¹和P¹、D²和P²完成所有顶点到所有顶点的最短路径的计算。
    首先我们针对下图的左网图准备两个矩阵D^-1和P^-1，就是网图的邻接矩阵，初设为P[j][j] = j这样的矩阵，它主要用来存储路径。
    
    具体代码如下，注意是：求所有顶点到所有顶点的最短路径，因此Pathmatirx和ShortPathTable都是二维数组。

1. /* Floyd算法，求网图G中各顶点v到其余顶点w的最短路径P[v][w]及带权长度D[v][w]。 */ 
   
2. void ShortestPath_Floyd(MGraph G, Patharc *P, ShortPathTable *D)
3. { 
4.     int v,w,k; 
5.     for(v=0; v<G.numVertexes; ++v)            /* 初始化D与P */ 
6.     { 
7.         for(w=0; w<G.numVertexes; ++w) 
8.         {
9.             (*D)[v][w]=G.arc[v][w];            /* D[v][w]值即为对应点间的权值 */
10.             (*P)[v][w]=w;                    /* 初始化P */
11.         }
12.     }
13.     for(k=0; k<G.numVertexes; ++k) 
14.     {
15.         for(v=0; v<G.numVertexes; ++v) 
16.         { 
17.             for(w=0; w<G.numVertexes; ++w) 
18.             {
19.                 if ((*D)[v][w]>(*D)[v][k]+(*D)[k][w])
20.                 {
21.                     /* 如果经过下标为k顶点路径比原两点间路径更短 */
22.                     
23.                     (*D)[v][w]=(*D)[v][k]+(*D)[k][w];    /* 将当前两点间权值设为更小的一个 */
24.                     (*P)[v][w]=(*P)[v][k];                /* 路径设置为经过下标为k的顶点 */
25.                 }
26.             }
27.         }
28.     }
29. }

 
   下面介绍下详细的执行过程：

    （1）程序开始运行，第4-11行就是初始化了D和P，使得它们成为   
上
图  
  的两个矩阵。从矩阵也得到，v0->v1路径权值为1，v0->v2路径权值为5，v0->v3无边连线，所以路径权值为极大值65535。

    （2）第12~25行，是算法的主循环，一共三层嵌套，k代表的就是中转顶点的下标。v代表起始顶点，w代表结束顶点。

    （3）当k = 0时，也就是所有的顶点都经过v0中转，计算是否有最短路径的变化。可惜结果是，没有任何变化，如下图所示。

   
 （4）当k = 1时，也就是所有的顶点都经过v1中转。此时，当v = 0 时，原本D[0][2] = 5，现在由于D[0][1] + D[1][2] = 4。因此由代码的的第20行，二者取其最小值，得到D[0][2] = 4，同理可得D[0][3] = 8、D[0][4] = 6，当v = 2、3、4时，也修改了一些数据，请看下图左图中虚线框数据。由于这些最小权值的修正，所以在路径矩阵P上，也要做处理，将它们都改为当前的P[v][k]值，见代码第21行。

  
  （5）接下来就是k = 2，一直到8结束，表示针对每个顶点做中转得到的计算结果，当然，我们也要清楚，D0是以
D-1为基础，D1是以D0为基础，……，D8是以D7为基础的。最终，当k = 8时，两个矩阵数据如下图所示。

   
 至此，我们的最短路径就算是完成了。可以看到矩阵第v0行的数值与迪杰斯特拉算法求得的D数组的数值是完全相同。而且这里是所有顶点到所有顶点的最短路径权值和都可以计算出。

    那么如何由P这个路径数组得出具体的最短路径呢？以v0到v8为例，从上图的右图第v8列，P[0][8]= 1，得到要经过顶点v1，然后将1取代0，得到P[1][8] = 2，说明要经过v2，然后2取代1得到P[2][8] = 4，说明要经过v4，然后4取代2，得到P[4][8]= 3，说明要经过3，……..，这样很容易就推倒出最终的最短路径值为v0->v1->v2->v4->v3->v6->v7->v8。

    求最短路径的显示代码可以这样写：

1. for(v=0; v<G.numVertexes; ++v) 
   
2.     { 
3.         for(w=v+1; w<G.numVertexes; w++) 
4.         {
5.             printf(“v%d-v%d weight: %d “,v,w,D[v][w]);
6.             k=P[v][w];                /* 获得第一个路径顶点下标 */
7.             printf(” path: %d”,v);    /* 打印源点 */
8.             while(k!=w)                /* 如果路径顶点下标不是终点 */
9.             {
10.                 printf(” -> %d”,k);    /* 打印路径顶点 */
11.                 k=P[k][w];            /* 获得下一个路径顶点下标 */
12.             }
13.             printf(” -> %d\n”,w);    /* 打印终点 */
14.         }
15.         printf(“\n”);
16.     }

    总体的代码如下：

1. #include “stdio.h” 
   
2. #include “stdlib.h” 
3. #include “io.h” 
4. #include “math.h” 
5. #include “time.h”
7. #define OK 1
8. #define ERROR 0
9. #define TRUE 1
10. #define FALSE 0
11. #define MAXEDGE 20
12. #define MAXVEX 20
13. #define INFINITY 65535
15. typedef int Status;    /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
17. typedef struct
18. {
19.     int vexs[MAXVEX];
20.     int arc[MAXVEX][MAXVEX];
21.     int numVertexes, numEdges;
22. }MGraph;
24. typedef int Patharc[MAXVEX][MAXVEX];
25. typedef int ShortPathTable[MAXVEX][MAXVEX];
27. /* 构件图 */
28. void CreateMGraph(MGraph *G)
29. {
30.     int i, j;
32.     /* printf(“请输入边数和顶点数:”); */
33.     G–>numEdges=16;
34.     G–>numVertexes=9;
36.     for (i = 0; i < G–>numVertexes; i++)/* 初始化图 */
37.     {
38.         G–>vexs[i]=i;
39.     }
41.     for (i = 0; i < G–>numVertexes; i++)/* 初始化图 */
42.     {
43.         for ( j = 0; j < G–>numVertexes; j++)
44.         {
45.             if (i==j)
46.                 G–>arc[i][j]=0;
47.             else
48.                 G–>arc[i][j] = G–>arc[j][i] = INFINITY;
49.         }
50.     }
52.     G–>arc[0][1]=1;
53.     G–>arc[0][2]=5; 
54.     G–>arc[1][2]=3; 
55.     G–>arc[1][3]=7; 
56.     G–>arc[1][4]=5; 
58.     G–>arc[2][4]=1; 
59.     G–>arc[2][5]=7; 
60.     G–>arc[3][4]=2; 
61.     G–>arc[3][6]=3; 
62.     G–>arc[4][5]=3;
64.     G–>arc[4][6]=6;
65.     G–>arc[4][7]=9; 
66.     G–>arc[5][7]=5; 
67.     G–>arc[6][7]=2; 
68.     G–>arc[6][8]=7;
70.     G–>arc[7][8]=4;
73.     for(i = 0; i < G–>numVertexes; i++)
74.     {
75.         for(j = i; j < G–>numVertexes; j++)
76.         {
77.             G–>arc[j][i] =G–>arc[i][j];
78.         }
79.     }
81. }
83. /* Floyd算法，求网图G中各顶点v到其余顶点w的最短路径P[v][w]及带权长度D[v][w]。 */ 
84. void ShortestPath_Floyd(MGraph G, Patharc *P, ShortPathTable *D)
85. { 
86.     int v,w,k; 
87.     for(v=0; v<G.numVertexes; ++v) /* 初始化D与P */ 
88.     { 
89.         for(w=0; w<G.numVertexes; ++w) 
90.         {
91.             (*D)[v][w]=G.arc[v][w];    /* D[v][w]值即为对应点间的权值 */
92.             (*P)[v][w]=w;                /* 初始化P */
93.         }
94.     }
95.     for(k=0; k<G.numVertexes; ++k) 
96.     {
97.         for(v=0; v<G.numVertexes; ++v) 
98.         { 
99.             for(w=0; w<G.numVertexes; ++w) 
100.             {
101.                 if ((*D)[v][w]>(*D)[v][k]+(*D)[k][w])
102.                 {/* 如果经过下标为k顶点路径比原两点间路径更短 */
103.                     (*D)[v][w]=(*D)[v][k]+(*D)[k][w];/* 将当前两点间权值设为更小的一个 */
104.                     (*P)[v][w]=(*P)[v][k];/* 路径设置为经过下标为k的顶点 */
105.                 }
106.             }
107.         }
108.     }
109. }
111. int main(void)
112. { 
113.     int v,w,k; 
114.     MGraph G; 
115.     
116.     Patharc P; 
117.     ShortPathTable D; /* 求某点到其余各点的最短路径 */ 
118.     
119.     CreateMGraph(&G);
120.     
121.     ShortestPath_Floyd(G,&P,&D); 
123.     printf(“各顶点间最短路径如下:\n”); 
124.     for(v=0; v<G.numVertexes; ++v) 
125.     { 
126.         for(w=v+1; w<G.numVertexes; w++) 
127.         {
128.             printf(“v%d-v%d weight: %d “,v,w,D[v][w]);
129.             k=P[v][w];                /* 获得第一个路径顶点下标 */
130.             printf(” path: %d”,v);    /* 打印源点 */
131.             while(k!=w)                /* 如果路径顶点下标不是终点 */
132.             {
133.                 printf(” -> %d”,k);    /* 打印路径顶点 */
134.                 k=P[k][w];            /* 获得下一个路径顶点下标 */
135.             }
136.             printf(” -> %d\n”,w);    /* 打印终点 */
137.         }
138.         printf(“\n”);
139.     }
141.     printf(“最短路径D\n”);
142.     for(v=0; v<G.numVertexes; ++v) 
143.     { 
144.         for(w=0; w<G.numVertexes; ++w) 
145.         {
146.             printf(“%d\t”,D[v][w]);
147.         }
148.         printf(“\n”);
149.     }
150.     printf(“最短路径P\n”);
151.     for(v=0; v<G.numVertexes; ++v) 
152.     { 
153.         for(w=0; w<G.numVertexes; ++w) 
154.         {
155.             printf(“%d “,P[v][w]);
156.         }
157.         printf(“\n”);
158.     }
160.     return 0;
161. }