【贪心算法】单源最短路径问题

      1、问题描述

     给定带权有向图G =(V,E)，其中每条边的权是非负实数。另外，还给定V中的一个顶点，称为源。现在要计算从源到所有其他各顶点的最短路长度。这里路的长度是指路上各边权之和。这个问题通常称为单源最短路径问题。

    2、Dijkstra算法

     Dijkstra算法是解单源最短路径问题的贪心算法。
    其基本思想是，设置顶点集合S并不断地作贪心选择来扩充这个集合。一个顶点属于集合S当且仅当从源到该顶点的最短路径长度已知。初始时，S中仅含有源。设u是G的某一个顶点，把从源到u且中间只经过S中顶点的路称为从源到u的特殊路径，并用数组dist记录当前每个顶点所对应的最短特殊路径长度。Dijkstra算法每次从V-S中取出具有最短特殊路长度的顶点u，将u添加到S中，同时对数组dist作必要的修改。一旦S包含了所有V中顶点，dist就记录了从源到所有其他顶点之间的最短路径长度。

    Dijkstra算法可描述如下，其中输入带权有向图是G=(V,E)，V={1,2,…，n}，顶点v是源。c是一个二维数组，c[i][j]表示边(i,j)的权。当(i,j)不属于E时，c[i][j]是一个大数。dist[i]表示当前从源到顶点i的最短特殊路径长度。在Dijkstra算法中做贪心选择时，实际上是考虑当S添加u之后，可能出现一条到顶点的新的特殊路，如果这条新特殊路是先经过老的S到达顶点u,然后从u经过一条边直接到达顶点i，则这种路的最短长度是dist[u]+c[u][i]。如果dist[u]+c[u][i]<dist[i]，则需要更新dist[i]的值。步骤如下：

   (1) 用带权的邻接矩阵c来表示带权有向图, c[i][j]表示弧<vi,vj>上的权值。设S为已知最短路径的终点的集合,它的初始状态为空集。从源点v经过S到图上其余各点vi的当前最短路径长度的初值为：dist[i]=c[v][i], vi属于V.
   (2) 选择vu, 使得dist[u]=Min{dist[i] | vi属于V-S},vj就是长度最短的最短路径的终点。令S=S U {u}.

   (3) 修改从v到集合V-S上任一顶点vi的当前最短路径长度:如果 dist[u]+c[u][j]< dist[j] 则修改 dist[j]= dist[u]+c[u][j]. 
   (4) 重复操作(2),(3)共n-1次.

算法具体实现如下：

[cpp] view plain copy

1. //4d5 贪心算法 单源最短路径问题  
2. #include "stdafx.h"  
3. #include <iostream>   
4. #include <fstream>    
5. #include <string>   
6. using namespace std;   
7.   
8. const int N = 5;  
9. const int M = 1000;  
10. ifstream fin("4d5.txt");   
11.   
12. template<class Type>  
13. void Dijkstra(int n,int v,Type dist[],int prev[],Type c[][N+1]);  
14. void Traceback(int v,int i,int prev[]);//输出最短路径 v源点，i终点  
15.   
16. int main()  
17. {  
18.     int v = 1;//源点为1  
19.     int dist[N+1],prev[N+1],c[N+1][N+1];  
20.   
21.     cout<<"有向图权的矩阵为："<<endl;  
22.     for(int i=1; i<=N; i++)  
23.     {  
24.         for(int j=1; j<=N; j++)  
25.         {  
26.             fin>>c[i][j];      
27.             cout<<c[i][j]<<" ";    
28.         }  
29.         cout<<endl;  
30.     }  
31.   
32.     Dijkstra(N,v,dist,prev,c);  
33.   
34.     for(int i=2; i<=N; i++)  
35.     {  
36.         cout<<"源点1到点"<<i<<"的最短路径长度为:"<<dist[i]<<"，其路径为";  
37.         Traceback(1,i,prev);  
38.         cout<<endl;  
39.     }  
40.   
41.     return 0;  
42. }  
43.   
44.   
45. template<class Type>  
46. void Dijkstra(int n,int v,Type dist[],int prev[],Type c[][N+1])  
47. {  
48.     bool s[N+1];  
49.     for(int i=1; i<=n; i++)  
50.     {  
51.         dist[i] = c[v][i];//dist[i]表示当前从源到顶点i的最短特殊路径长度  
52.         s[i] = false;     //s[i]是false说明i不是U中的点，此处是初始化
53.   
54.         if(dist[i] == M)     //不能直达
55.         {  
56.             prev[i] = 0;//记录从源到顶点i的最短路径i的前一个顶点  
57.         }  
58.         else  
59.         {  
60.             prev[i] = v;  //初始化时候可达，那么点i路径的前一个节点就是v
61.         }  
62.     }  
63.   
64.     dist[v] = 0;  
65.     s[v] = true;  
66.   
67.     for(int i=1; i<n; i++)  
68.     {  
69.         int temp = M;  
70.         int u = v;//上一顶点  
71.   
72.         //取出V-S中具有最短特殊路径长度的顶点u  
73.         for(int j=1; j<=n; j++)  
74.         {  
75.             if((!s[j]) && (dist[j]<temp))  
76.             {  
77.                 u = j;  
78.                 temp = dist[j];  
79.             }  
80.         }  
81.         s[u] = true;  //V-S中具有最短特殊路径长度的顶点u 加入S
82.   
83.         //根据作出的贪心选择更新Dist值  
84.         for(int j=1; j<=n; j++)  
85.         {  
86.             if((!s[j]) && (c[u][j]<M))      
87.             {  
88.                 Type newdist = dist[u] + c[u][j];    //源点到新加入S的点的距离+新加入点到点j得距离
89.                                                                        //这里为什么只考虑刚加入的u作为源点到j的中间节点？
90.                                                                        //因为其他的u已经之前考虑过了。dist[j]就是考虑过其他的u 更新过的
91.                 if(newdist < dist[j])      //若这个距离比源点直接到V-S中的点就的dist[j]小，那么源点到j的最短距离就                                                                     //是newdist 
92.                 {  
93.                     dist[j] = newdist;  
94.                     prev[j] = u;  
95.                 }  
96.             }  
97.         }  
98.     }  
99. }  
100.   
101. //输出最短路径 v源点，i终点  
102. void Traceback(int v,int i,int prev[])  
103. {  
104.     if(v == i)  
105.     {  
106.         cout<<i;  
107.         return;  
108.     }  
109.     Traceback(v,prev[i],prev);  
110.     cout<<"->"<<i;  
111. }  

     例，如图中的有向图，应用 Dijkstra算法计算从源顶点1到其它顶点间最短路径的过程如下表所示：

       3、贪心选择性质

    从V-S中选择具有最短特殊路径的顶点u，从而确定从源到u的最短路径长度dist[u]。为什么从源到u没有更短的其他路径？如图，如果存在一条从源到u且长度比dist[u]更短的路，设这条路初次走出S之外到达的顶点为x(x属于V-S)，然后徘徊于S内外若干次，左后离开S到达u。在这条路上分别记d(v,x),d(x,u)和d(v,u)为顶点v到顶点x,顶点x到顶点u，顶点v到顶点u的路长。则有：

     dist[x]<=dist[u]与u是当前贪心选择矛盾！

    4、最优子结构性质

     该性质描述为：如果S(i,j)={Vi....Vk..Vs...Vj}是从顶点i到j的最短路径，k和s是这条路径上的一个中间顶点，那么S(k,s)必定是从k到s的最短路径。下面证明该性质的正确性。
     假设S(i,j)={Vi....Vk..Vs...Vj}是从顶点i到j的最短路径，则有S(i,j)=S(i,k)+S(k,s)+S(s,j)。而S(k,s)不是从k到s的最短距离，那么必定存在另一条从k到s的最短路径S'(k,s)，那么S'(i,j)=S(i,k)+S'(k,s)+S(s,j)<S(i,j)。则与S(i,j)是从i到j的最短路径相矛盾。因此该性质得证。

     5、计算复杂性

     对于一个具有n个顶点和e条边的带权有向图，如果用带权邻接矩阵表示这个图，那么Dijkstra算法的主循环体需要O(n)时间。这个循环需要执行n-1次，所以完成循环需要O(n^2)时间。算法的其余部分所需要的时间不超过O(n^2)。

     程序运行结果为：

 

https://blog.csdn.net/liufeng_king/article/details/8726066