算法导论学习笔记（19）——每对顶点间的最短路径（基于Floyd_Warshall算法）

Floyd-Warshall算法的运行时间为Θ(V³)，它同样允许存在负权边，但假设不存在负权回路。该算法考虑的最优子结构与上述描述类似，即最短路径的子路径是最短路径。但是，它对中间路径的范围加以限制，使其增长与最短路径的最大边数的增长同步。令d_ij^(k)=为从顶点i到顶点j、且满足所有中间顶点属于集合{1,2,…,k}的一条最短路径的权值，定义递归解：如果k=0，d_ij^(k)=w_ij；如果k≥1，d_ij^(k)=min{ d_ij^(k-1), d_ik^(k-1)+ d_kj^(k-1)}。可以想象，当k=1时，i到j的最短路径或者由边(i,j)构成，或者由边(i,1)、(1,j)构成。当k=2时，i到j的最短路径可能由子路径i到2和子路径2到j构成，而子路径2到j又可能由边(2,1)、(1,j)构成，即k=2的解包含了k=1的解。以此类推，当k=n时，即可得到每对顶点间最短路径的权值。

为了构造最短路径，定义π_ij^(k)为从i出发的一条最短路径上顶点j的前趋，而这条路径上的中间顶点属于集合{1,2,…,k}。定义π_ij^(k)的递归公式，对于k=0，如果i=j或w_ij=∞，π_ij⁽⁰⁾ =NIT(-1)；如果i≠j和w_ij<∞，π_ij⁽⁰⁾ =i。对于k≥1，如果d_ij^(k-1)≤d_ik^(k-1)+ d_kj^(k-1)，π_ij^(k) =π_ij^(k-1)；如果d_ij^(k-1)>d_ik^(k-1)+ d_kj^(k-1)，π_ij^(k) =π_kj^(k-1)。

完整的实现代码如下：

完整的实现代码如下：

view plain copy to clipboard print ?

1. #include <iostream> 
2. #include <string>  
3. #include <stdio.h>  
4. using namespace std;    
5. #define MaxVertexNum 100    
6. #define INF 32767    
7. typedef struct   
8. {    
9.     char vertex[MaxVertexNum];    
10.     int edges[MaxVertexNum][MaxVertexNum];    
11.     int n,e;    
12. }MGraph;    
13.  
14. void CreateMGraph(MGraph &G)    
15. {    
16.     int i,j,k,p;    
17.     cout<<"请输入顶点数和边数:";    
18.     cin>>G.n>>G.e;    
19.     cout<<"请输入顶点元素:";    
20.     for (i=0;i<G.n;i++)    
21.     {    
22.         cin>>G.vertex[i];    
23.     }    
24.     for (i=0;i<G.n;i++)    
25.     {    
26.         for (j=0;j<G.n;j++)    
27.         {    
28.             G.edges[i][j]=INF;    
29.             if (i==j)    
30.             {    
31.                 G.edges[i][j]=0;    
32.             }    
33.         }    
34.     }       
35.     for (k=0;k<G.e;k++)    
36.     {    
37.         cout<<"请输入第"<<k+1<<"条弧头弧尾序号和相应的权值:";    
38.         cin>>i>>j>>p;    
39.         G.edges[i][j]=p;    
40.     }    
41. }    
42. void Dispath(int A[][MaxVertexNum],int path[][MaxVertexNum],int n); 
43.  
44. void Floyd(MGraph G) 
45. { 
46.     int A[MaxVertexNum][MaxVertexNum],path[MaxVertexNum][MaxVertexNum]; 
47.     int i,j,k; 
48.     for (i=0;i<G.n;i++) 
49.     { 
50.         for (j=0;j<G.n;j++) 
51.         { 
52.             A[i][j]=G.edges[i][j]; 
53.             path[i][j]=-1; 
54.         } 
55.     } 
56.     for (k=0;k<G.n;k++) 
57.     { 
58.         for (i=0;i<G.n;i++) 
59.         { 
60.             for (j=0;j<G.n;j++) 
61.             { 
62.                 if (A[i][j]>A[i][k]+A[k][j]) 
63.                 { 
64.                     A[i][j]=A[i][k]+A[k][j]; 
65.                     path[i][j]=k; 
66.                 } 
67.             } 
68.         } 
69.     } 
70.     Dispath(A,path,G.n); 
71. } 
72.  
73. void Ppath(int path[][MaxVertexNum],int i,int j) 
74. { 
75.     int k; 
76.     k=path[i][j]; 
77.     if (k==-1) 
78.     { 
79.         return; 
80.     } 
81.     Ppath(path,i,k); 
82.     printf("%d",k); 
83.     Ppath(path,k,j); 
84. } 
85.  
86. void Dispath(int A[][MaxVertexNum],int path[][MaxVertexNum],int n) 
87. { 
88.     int i,j; 
89.     for (i=0;i<n;i++) 
90.     { 
91.         for (j=0;j<n;j++) 
92.         { 
93.             if (A[i][j]==INF) 
94.             { 
95.                 if (i!=j) 
96.                 { 
97.                     printf("从%d到%d没有路径/n",i,j); 
98.                 } 
99.             } 
100.             else 
101.             { 
102.                 printf("  从%d到%d=>路径长度:%d路径:",i,j,A[i][j]); 
103.                 printf("%d,",i); 
104.                 Ppath(path,i,j); 
105.                 printf("%d/n",j); 
106.             } 
107.         } 
108.     } 
109. } 
110.  
111. int main() 
112. { 
113.     MGraph G; 
114.     CreateMGraph(G); 
115.     Floyd(G); 
116.     return 0; 
117. }