Book 最短路算法

最新推荐文章于 2025-03-06 21:26:50 发布

weixin_30457551

最新推荐文章于 2025-03-06 21:26:50 发布

阅读量70

点赞数

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/wuyuewoniu/p/4419535.html

用HDU2544整理一下最近学的最短路算法

1.Dijkstra算法

原理：集合S表示已经找到最短路径的点，d[]表示当前各点到源点的距离

初始时，集合里面只有源点，当每个点u进入集合S时，用d[u]+w[u][v]更新距离

再重复这个步骤，选取S外所有点中d[]最小的进入集合

直到所有的点都进入S集合

局限性：图的边权必须为正

复杂度：O(V*V),堆优化（（E+V）logV）

(1)用邻接矩阵实现

 1 #include<iostream>  
 2 #include<cstdio>  
 3 #include<cstring> 
 4 #include <cmath> 
 5 #include<stack>
 6 #include<vector>
 7 #include<map> 
 8 #include<set>
 9 #include<queue> 
10 #include<algorithm>  
11 using namespace std;
12 
13 typedef long long LL;
14 const int INF = (1<<30)-1;
15 const int mod=1000000007;
16 const int maxn=10005;
17 int w[maxn][maxn],d[maxn],used[maxn];
18 int n,m;
19 
20 void dijkstra(int s){
21     memset(used,0,sizeof(used));
22     for(int i=1;i<=n;i++) d[i]=INF;
23     d[s]=0;
24     
25     for(int k=1;k<=n;k++){
26         int p,m=INF;
27         for(int i=1;i<=n;i++) if(!used[i]&&d[i]<m) m=d[p=i];
28         used[p]=1;
29         for(int i=1;i<=n;i++) d[i]=min(d[i],d[p]+w[p][i]);
30     }
31 }
32 
33 int main(){
34     int a,b,c;
35     while(scanf("%d %d",&n,&m)!=EOF&&n&&m){
36         for(int i=1;i<=n;i++){
37             for(int j=1;j<=n;j++){
38                 if(i==j) w[i][j]=0;
39                 else w[i][j]=INF;
40             }            
41         }
42         
43         for(int i=1;i<=m;i++){
44             scanf("%d %d %d",&a,&b,&c);
45             w[a][b]=w[b][a]=c;
46         }
47         dijkstra(1);
48         printf("%d\n",d[n]);

49     }
50     return 0;
51 }

View Code

(2)用邻接表实现

注意记得每次调用dijkstra()时，first[]置为-1

 1 #include<iostream>  
 2 #include<cstdio>  
 3 #include<cstring> 
 4 #include <cmath> 
 5 #include<stack>
 6 #include<vector>
 7 #include<map> 
 8 #include<set>
 9 #include<queue> 
10 #include<algorithm>  
11 using namespace std;
12 
13 typedef long long LL;
14 const int INF = (1<<30)-1;
15 const int mod=1000000007;
16 const int maxn=10005;
17 int d[maxn],used[maxn],firstt[maxn],nextt[maxn];
18 int n,m,ecnt;
19 
20 struct edge{
21     int v,cost;
22 } e[maxn];
23 
24 void dijkstra(int s){
25     memset(used,0,sizeof(used));
26     for(int i=1;i<=n;i++) d[i]=INF;
27     d[s]=0;
28     
29     for(int k=1;k<=n;k++){
30         int p,m=INF;
31         for(int i=1;i<=n;i++) if(!used[i]&&d[i]<m) m=d[p=i];
32         used[p]=1;
33         for(int i=firstt[p];i!=-1;i=nextt[i]){
34             int v=e[i].v;
35             if(d[v]>d[p]+e[i].cost) 
36             d[v]=d[p]+e[i].cost;
37         }
38     }
39 }
40 
41 void addedges(int u,int v,int w){
42     nextt[++ecnt]=firstt[u];
43     e[ecnt].v=v;
44     e[ecnt].cost=w;
45     firstt[u]=ecnt;    
46 }
47 
48 int main(){
49     int a,b,c;
50     while(scanf("%d %d",&n,&m)!=EOF&&n&&m){
51         ecnt=0;
52         memset(firstt,-1,sizeof(firstt));
53         
54         for(int i=1;i<=m;i++){
55             scanf("%d %d %d",&a,&b,&c);
56             addedges(a,b,c);
57             addedges(b,a,c);
58         }
59         dijkstra(1);
60         printf("%d\n",d[n]);
61     }
62     return 0;
63 }

View Code

(3)堆（优先队列）优化
参看紫书上的解释，STL中的pair是专门将两个类型捆绑起来的，

而且pair定义了它自己的排序规则，先比较第一维，相等时才比较第二维，所以需要按照(d[i],i)的顺序组合。

 1 #include<iostream>  
 2 #include<cstdio>  
 3 #include<cstring> 
 4 #include <cmath> 
 5 #include<stack>
 6 #include<vector>
 7 #include<map> 
 8 #include<set>
 9 #include<queue> 
10 #include<algorithm>  
11 #define MP(a,b) make_pair(a,b)
12 using namespace std;
13 
14 typedef long long LL;
15 typedef pair<int,int> pii;
16 const int INF = (1<<30)-1;
17 const int mod=1000000007;
18 const int maxn=100005;
19 int d[maxn],firstt[maxn],nextt[maxn];
20 int n,m,ecnt;
21 
22 struct edge{
23     int v,cost;
24     friend bool operator < (edge a,edge b){
25         return a.cost>b.cost;
26     }
27 }e[maxn];
28 
29 void addedges(int u,int v,int c){
30     nextt[++ecnt]=firstt[u];
31     e[ecnt].v=v;
32     e[ecnt].cost=c;
33     firstt[u]=ecnt;
34 }
35 
36 void dijkstra(int s){
37     priority_queue<pii> pq;
38     for(int i=1;i<=n;i++) d[i]=INF;
39     d[s]=0;
40     pq.push(MP(d[s],1));
41     while(!pq.empty()){
42         pii x=pq.top();pq.pop();
43         if(d[x.second]<x.first) continue;//当前状态没有现在dis[]数组里面的优，所以不用再继续判断下去 
44         for(int i=firstt[x.second];i!=-1;i=nextt[i]){
45             int v=e[i].v;
46             if(d[v]>d[x.second]+e[i].cost){
47                 d[v]=d[x.second]+e[i].cost;
48                 pq.push(MP(d[v],v));
49             }            
50         }        
51     }
52 }
53 
54 int main(){
55     int a,b,c;
56     while(scanf("%d %d",&n,&m)!=EOF&&n&&m){
57         memset(firstt,-1,sizeof(firstt));
58         ecnt=0;
59         for(int i=1;i<=m;i++){
60             scanf("%d %d %d",&a,&b,&c);
61             addedges(a,b,c);
62             addedges(b,a,c);
63         }
64         dijkstra(1);
65         printf("%d\n",d[n]);
66     }
67     return 0;
68 }

View Code

(4)用vector存图实现的

 1 #include<iostream>  
 2 #include<cstdio>  
 3 #include<cstring> 
 4 #include <cmath> 
 5 #include<stack>
 6 #include<vector>
 7 #include<map> 
 8 #include<set>
 9 #include<queue> 
10 #include<algorithm>  
11 using namespace std;
12 
13 typedef long long LL;
14 const int INF = (1<<30)-1;
15 const int mod=1000000007;
16 const int maxn=10005;
17 int d[maxn];
18 
19 typedef struct edge{
20     int to,distance;
21     edge(){}
22     edge(int to,int distance) :to(to),distance(distance){}
23 };
24 typedef pair<int,int> P;
25 vector<edge> G[maxn];
26 int n,m,k;
27 
28 void dijkstra(int s){
29     
30     priority_queue<P,vector<P> ,greater<P> > q;
31     for(int i=0;i < n;i++) d[i]=INF;
32     d[s]=0;
33     q.push(P(0,s));
34     
35     while(!q.empty()){
36         P p=q.top();q.pop();
37         int v=p.second;
38         if(d[v]<p.first) continue;
39         for(int i=0;i<G[v].size();i++){
40             edge e=G[v][i];
41         
42             if(d[e.to] > d[v]+e.distance){
43             
44                 d[e.to] = d[v]+e.distance;
45                 q.push(P(d[e.to],e.to));
46             }    
47         }
48     }
49 }
50 
51 int main(){
52     while(scanf("%d %d",&n,&m)!=EOF){
53         if(n==0&&m==0) break;
54             for(int i=0;i<n;i++) G[i].clear();
55         while(m--){
56             int u,v,w;
57             scanf("%d %d %d",&u,&v,&w);
58             u--;v--;
59             G[u].push_back(edge(v,w));
60             G[v].push_back(edge(u,w));            
61         }
62         dijkstra(0);
63         printf("%d\n",d[n-1]);
64     }
65         
66     return 0;
67 }

View Code

2.Bellman_Ford算法

原理：对于图G(V,E),Bellman_Ford是对整个图进行V-1次松弛，每次松弛检查每条边，如果d[v]>d[u]+cost,那么则更新d[v]

应用：可以用来判断负环，如果没有负权回路的话，那么任意两点间的路径最多经过n-2个点，

即最多松弛n-1次，如果有负权回路，那么第n次松弛操作仍然会成功。

复杂度：O(VE)

 1 #include<iostream>  
 2 #include<cstdio>  
 3 #include<cstring> 
 4 #include <cmath> 
 5 #include<stack>
 6 #include<vector>
 7 #include<map> 
 8 #include<set>
 9 #include<queue> 
10 #include<algorithm>  
11 using namespace std;
12 
13 typedef long long LL;
14 const int INF = (1<<30)-1;
15 const int mod=1000000007;
16 const int maxn=100005;
17 int d[maxn];
18 int n,m,ecnt;
19 
20 struct edge{
21     int u,v,cost;
22 } e[maxn];
23 
24 void addedges(int u,int v,int c){
25     e[++ecnt].u=u;
26     e[ecnt].v=v;
27     e[ecnt].cost=c;    
28 }
29 
30 void Bellman_Ford(int s){
31     for(int i=1;i<=n;i++) d[i]=INF;
32     d[s]=0;
33     
34     for(int i=1;i<n;i++){
35         for(int j=1;j<=ecnt;j++){
36             if(d[e[j].v]>d[e[j].u]+e[j].cost)
37             d[e[j].v]=d[e[j].u]+e[j].cost;
38         }
39     }
40 }
41 
42 int main(){
43     int a,b,c;
44     while(scanf("%d %d",&n,&m)!=EOF&&n&&m){
45         ecnt=0;
46         for(int i=1;i<=m;i++){
47             scanf("%d %d %d",&a,&b,&c);
48             addedges(a,b,c);
49             addedges(b,a,c);
50         }
51         Bellman_Ford(1);
52         printf("%d\n",d[n]);
53     }
54     return 0;
55 }