最短路模板

最短路

Dijkstra算法（常用）

·有重边的情况下尽量用邻接表存图

·记得处理第一个加入集合的点

·Dijkstra算法没法处理负权边

基础版本

1. void dijkstra(int s){//记得处理第一个加入集合的点   
2.     for(int i=1;i<=n;i++)dis[i]=inf;  
3.     dis[s]=0;  
4.     for(int i=1;i<=n;i++)  
5.     {  
6.         int k=0;  
7.         for(int j=1;j<=n;j++)  
8.             if(!vis[j]&&(k==0 || dis[j]<dis[k]))  
9.                 k=j;  
10.         vis[k]=1;  
11.         for(int j=1;j<=n;j++){  
12.             if(!vis[j]&&dis[k]+a[k][j]<dis[j])  
13.                 dis[j]=dis[k]+a[k][j];  
14.         }  
15.     }  
16. }  

优化版本（优先队列）

1. struct element{  
2.     int v,w;  
3.     friend bool operator < (element a,element b){  
4.         return a.w>b.w;  
5.     }  
6. };  
7. struct node{  
8.     int v,w,next;  
9. }e[maxn*6];  
10.   
11. void adde(int u,int v,int w){  
12.     e[++cnt].v=v;  
13.     e[cnt].w=w;  
14.     e[cnt].next=head[u];  
15.     head[u]=cnt;  
16. }  
17.   
18. void dijkstra(int s){  
19.     priority_queue<element> q;  
20.     memset(dis,inf,sizeof(dis));  
21.     element k;  
22.     q.push((element){s,0});  
23.     dis[s]=0;  
24.     while(!q.empty()){  
25.         k =q.top();  
26.         int v=k.v,w=k.w;  
27.         q.pop();  
28.         if(vis[v])continue;//这条边已经加入集合中   
29.         vis[v]=1;  
30.         dis[v]=w;  
31.         for(int i=head[v];i!=0;i=e[i].next){//最短边对应点的每条边都入队列   
32.             q.push((element){e[i].v,e[i].w+w});  
33.         }  
34.     }  
35. }  

 

Bellman-Ford(负权最短路算法)

·此算法最大优势是处理负边权，判断负环（正环）

·至多执行n-1次

·用数组+结构体存图，因为是遍历边而不是点

·复杂度O（ne），适用于稀疏图

1. struct edge  
2. {  
3.     long long x,y;  
4.     long long cost;  
5. };  
6. edge v[3*N];  
7. long long dis[N];  
8. bool Bellman_Ford()  
9. {  
10.     for(int i=1;i<=n;++i)  
11.         dis[i]=(i==s? 0:MAX);//初始化  
12.     for(int i=1;i<n;++i)  
13.         for(int j=1;j<=m;++j)  
14.         {  
15.             if(dis[v[j].y]>dis[v[j].x]+v[j].cost)//松弛，因为是有向图，方向不能反  
16.                 dis[v[j].y]=dis[v[j].x]+v[j].cost;  
17.         }  
18.     bool flag=1;//标记有无负环  
19.     for(int i=1;i<=m;++i)  
20.         if(dis[v[i].y]>dis[v[i].x]+v[i].cost)//松弛是否成功  
21.         {  
22.             flag=0;//成功则有负环  
23.             break;  
24.         }  
25.     return flag;  
26. }  

 

SPFA算法

·对Ford算法的优化

·处理负环正环

非递归方式

1. bool SPFA()  
2. {  
3.     queue<int> q;//队列  
4.     memset(dis,127/3,sizeof(dis));//初始化一个很大的数  
5.     dis[s]=0;//原点最短路是0  
6.     q.push(s);//原点入队  
7.     vis[s]=1;//标记入队  
8.     while(!q.empty())//队列不空说明没跑完  
9.     {  
10.         int k=q.front();//取出队首  
11.         q.pop();  
12.         vis[k]=0;//擦去标记  
13.         ++cnt[k];//统计次数  
14.         if(cnt[k]>=n)//如果超过n-1说明有负环  
15.             return 0;//报错  
16.         for(int i=head[k];i!=0;i=e[i].next)//邻接表遍历相连的边  
17.             if(dis[e[i].v]>dis[k]+e[i].w)//如果可以松弛  
18.             {  
19.                 dis[e[i].v]=dis[k]+e[i].w;//松弛  
20.                 if(!vis[e[i].v])//如果被松弛的点不在队列里  
21.                 {  
22.                     vis[e[i].v]=1;//标记入队  
23.                     q.push(e[i].v);//入队  
24.                 }  
25.             }  
26.     }  
27.     return 1;//顺利完成  
28. }  

 

递归方式

1. bool SPFA(int u)  
2. {  
3.     vis[u]=1;  
4.     for(int k=f[u];k;k=e[k].next)//遍历后面的整个路径  
5.     {  
6.         int v=e[k].v,w=e[k].w;  
7.         if(d[u]+w<d[v])//能松弛  
8.         {  
9.             d[v]=d[u]+w;  
10.             if(!vis[v])//不重复  
11.                 if(!SPFA(v))//如果后面的路径有重复的  
12.                     return 0;//有负环  
13.             else  
14.                 return 0;//重复了，直接说明有负环  
15.         }  
16.     }  
17.     vis[u]=0;//回溯  
18.     return 1;//没有负环  
19. }  

 

Floyd算法（容易被卡）

·唯一的多源最短路算法

·思想是DP

·外层枚举中间点，内层枚举起点，最内层枚举终点

基本模板

1. //提前将邻接矩阵存在dis数组里，其他不连通的地方初始化成无穷大  
2. for(int k=1;k<=n;++k)//枚举中间点  
3.     for(int i=1;i<=n;++i)//枚举起点  
4.         if(i!=k)//节省时间，如果一样就不往下走  
5.             for(int j=1;j<=n;++j)//枚举终点  
6.                 if(i!=j&&j!=k)//继续判断，如果有一样的就不往下走  
7.                     dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);//状态转移方程，也就是所谓的松弛操作  

 

扩展例题

洛谷P1119 灾后重建

题意：每个道路有排序的修建时间，询问多个时间点的s到t的最短路

题解：正好可以用Floyd的思想解决，每修好一次村子，跑一遍内层循环，

dis[0][i][j] 是原始邻接矩阵数据

状态转移方程：

dis[k][i][j]=min(dis[k−1][i][j],dis[k−1][i][k]+dis[k−1][k][j])

1. for(;t[k]<=w&&k<=n;++k)//如果询问的天数没有被处理到就以在k以前修好的村庄为中间点跑Floyd  
2.             for(int i=1;i<=n;++i)  
3.                 if(i!=k)  
4.                     for(int j=1;j<=n;++j)  
5.                         if(i!=j&&j!=k)  
6.                             dis[i][j]=dis[j][i]=min(dis[i][j],dis[i][k]+dis[k][j]);//板子