一、问题

 带权有向图G（E,V), 找出从给定源顶点s到其它顶点v的权最小路径。

“最短路径” = 最小权

二、问题求解：

求1到5的最短路径值？

三、执行过程：

如果大家对这个问题的要求还不是很明白的话那么我再带着大家走一遍：

第一次：从1–>2：10 此时从1–>3没有路径所有是无穷大  1–>4：30  1–>5：100那么我们发现这一组组最小的是10也就是2这一点，所以我们再把2这一点加到集合里面来，那么2这一点就可以当作一个桥来用，

第二次：此时我们再从1–>3就可以通过1–>2–>3： 60，其他的1–>4：30

1–>5：100 可以发现此时最小的应该是4，所以我们再把4这一点加入到这个集合里面来，如此重复的去做这些事情，到最后可以发现1–>5的最短路径应该是60（1–>4–>3–>5）

四、Dijkstra伪代码：

[cpp] 
view plain
copy
print
?

1. int dijkstra(int s,int t) {  
2.   
3.        初始化S={空集}  
4.   
5.        d[s] = 0; 其余d值为正无穷大  
6.   
7.        while (NOT t  in S)  
8.   
9.        {  
10.   
11.               取出不在S中的最小的d[i];  
12.   
13.               for (所有不在S中且与i相邻的点j)  
14.   
15.                 if (d[j] > d[i] + cost[i][j]) d[j] = d[i] + cost[i][j]; ( “松弛”操作” )  
16.   
17.               S = S + {i}; //把i点添加到集合S里  
18.   
19.        }  
20.   
21.        return d[t];  
22.   
23. }  

为何松弛操作：

也就是说如果1–>3这点的值为dist[3]>dist[2]+map[2][3]

那么dist[3]=dits[2]+map[2][3]

五、代码实现：

[cpp] 
view plain
copy
print
?

1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. #define MAX 9999999  
6.   
7. #define LEN 210  
8.   
9. int map[LEN][LEN];    //某点到某点两点间的的距离  
10.   
11. int dist[LEN];              //记录当前点到源点的最短路径长度  
12.   
13. int mark[LEN];           //加入进来的点的集合  
14.   
15.    
16.   
17. //初始化map为正无穷大  
18.   
19. void init(){  
20.   
21.        int i,j;  
22.   
23.        for(i=0;i<LEN;i++){  
24.   
25.               for(j=0;j<LEN;j++){  
26.   
27.                      map[i][j]=MAX;  
28.   
29.               }  
30.   
31.        }  
32.   
33.          
34.   
35. }  
36.   
37. //n:多少条路  start:起始点   
38.   
39. void myDijstra(int n,int start){  
40.   
41.        int i,j,min,k;  
42.   
43.        for(i=1;i<=n;i++){  
44.   
45.               mark[i]=0;//没有点加入  
46.   
47.               dist[i]=map[start][i];//初始  
48.   
49.                 
50.   
51.        }  
52.   
53.        mark[start]=1;//把起始点加进来  
54.   
55.        dist[start]=0;  
56.   
57.        for(i=1;i<=n;i++){  
58.   
59.               min=MAX;  
60.   
61.               for(j=1;j<=n;j++){  
62.   
63.                      if(!mark[j] && dist[j]<min){    //取出不在mark里的最小的dist[i]  
64.   
65.                             min=dist[j];  
66.   
67.                             k=j;//标记  
68.   
69.                      }  
70.   
71.               }  
72.   
73.               if(min==MAX)  
74.   
75.                      break;  
76.   
77.               mark[k]=1;//把K加进来  
78.   
79.               //做松弛操作  
80.   
81.               for(j=1;j<=n;j++){  
82.   
83.                      if(!mark[j] && dist[j]>dist[k]+map[k][j]){  
84.   
85.                             dist[j]=dist[k]+map[k][j];  
86.   
87.                      }  
88.   
89.               }  
90.   
91.        }  
92.   
93. }  
94.   
95.    
96.   
97. int main(){  
98.   
99.        int i,j,n,line;  
100.   
101.        int a,b,d;  
102.   
103.        cin>>n>>line;   //输入点和边  
104.   
105.        init();  
106.   
107.        for(i=0;i<line;i++){  
108.   
109.               cin>>a>>b>>d;  //输入各边的权值  
110.   
111.               if(map[a][b]>d){  
112.   
113.                      map[a][b]=map[b][a]=d;  
114.   
115.               }  
116.   
117.        }  
118.   
119.        myDijstra(n,1);//调用方法  
120.   
121.        //输出1到5的最短路径  
122.   
123.        cout<<dist[5]<<endl;  
124.   
125.        return 0;  
126.   
127. }  

六、测试数据：

5 7
1 2 10
1 4 30
1 5 100
2 3 50
3 5 10
4 3 20
4 5 60

结果：

• 上一篇错排原理的应用
• 下一篇HDOJ 3970 最短路径问题[Dijsktra算法的应用]

顶

6

踩

0