DIJ问题，最短路径

单源最短路径问题[Dijkstra实现]

一、问题

 带权有向图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 可以发现此时最小的应该是3，所以我们再把3这一点加入到这个集合里面来，如此重复的去做这些事情，到最后可以发现1à5的最短路径应该是60（1-->4-->3-->5）

 

四、Dijkstra伪代码：

[cpp] view plaincopyprint?

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. }  

int dijkstra(int s,int t) {

       初始化S={空集}

       d[s] = 0; 其余d值为正无穷大

       while (NOT t  in S)

       {

              取出不在S中的最小的d[i];

              for (所有不在S中且与i相邻的点j)

                if (d[j] > d[i] + cost[i][j]) d[j] = d[i] + cost[i][j]; ( “松弛”操作” )

              S = S + {i}; //把i点添加到集合S里

       }

       return d[t];

}

为何松弛操作：

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

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

五、代码实现：

[cpp] view plaincopyprint?

1. #include    
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
24.   
25.               for(j=0;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]
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
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<
124.   
125.        return 0;  
126.   
127. }  

#include 

using namespace std;

#define MAX 9999999

#define LEN 210

int map[LEN][LEN];    //某点到某点两点间的的距离

int dist[LEN];              //记录当前点到源点的最短路径长度

int mark[LEN];           //加入进来的点的集合

 

//初始化map为正无穷大

void init(){

       int i,j;

       for(i=0;idist[k]+map[k][j]){

                            dist[j]=dist[k]+map[k][j];

                     }

              }

       }

}

 

int main(){

       int i,j,n,line;

       int a,b,d;

       cin>>n>>line;   //输入点和边

       init();

       for(i=0;i>a>>b>>d;  //输入各边的权值

              if(map[a][b]>d){

                     map[a][b]=map[b][a]=d;

              }

       }

       myDijstra(n,1);//调用方法

       //输出1到5的最短路径

       cout<

六、测试数据：

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

 

结果：

分享到：