最短路问题 以hdu1874为例
题目链接:点击打开链接
第一种解法:Floyd算法
算法实现:使用一个邻接矩阵存储边权值,两两之间能访问的必为一个有限的数,不能访问则为无穷大(用2^29代替)。注意自身和自身距离为0。
对于一对顶点 u 和 v,看看是否存在一个断点 w 使得从 u 经过 w 到 v 比已知的路径更短(包含原始输入中从 u 直接到 v 的路程)。
对所有顶点进行如上松弛操作,得到的结果是两点之间的最短路程,也可判断两点是否连通。
算法缺点:
普通的Floyd算法时间复杂度为O(n^3),对于数据较多的情况容易TLE。但解决本题 HDU 1874 完全足够。
#include"stdio.h" #define Max 0xfffffff int n,m,map[201][201]; int min(int x,int y) { return x>y?y:x; } void getmap() { int a,b,i,j,l; for(i=0;i<n;i++) for(j=0;j<n;j++) map[i][j]=(i==j?0:Max); for(i=0;i<m;i++) { scanf("%d%d%d",&a,&b,&l); map[a][b]=map[b][a]=min(map[a][b],l); } } void floyd(int s,int e) { int i,j,k; for(k=0;k<n;k++) for(i=0;i<n;i++) for(j=0;j<n;j++) map[i][j]=min(map[i][j],map[i][k]+map[k][j]); printf("%d\n",map[s][e]<Max?map[s][e]:-1); } int main() { int s,e; while(scanf("%d%d",&n,&m)!=EOF) { getmap(); scanf("%d%d",&s,&e); floyd(s,e); } return 0; }
第二种解法:Dijkstra算法
这个算法比较经典,一般的最短路径都可以用这个来解决,耗时也比较少,不过不能处理负权路径
按路径长度递增次序产生最短路径算法:
把V分成两组:
(1)S:已求出最短路径的顶点的集合
(2)V-S=T:尚未确定最短路径的顶点集合
将T中顶点按最短路径递增的次序加入到S中,
保证:(1)从源点V0到S中各顶点的最短路径长度都不大于
从V0到T中任何顶点的最短路径长度
(2)每个顶点对应一个距离值
S中顶点:从V0到此顶点的最短路径长度
T中顶点:从V0到此顶点的只包括S中顶点作中间
顶点的最短路径长度
依据:可以证明V0到T中顶点Vk的最短路径,或是从V0到Vk的
直接路径的权值;或是从V0经S中顶点到Vk的路径权值之和
(反证法可证)
求最短路径步骤
算法步骤如下:
1. 初使时令 S={V0},T={其余顶点},T中顶点对应的距离值
若存在<V0,Vi>,d(V0,Vi)为<V0,Vi>弧上的权值
若不存在<V0,Vi>,d(V0,Vi)为∝
2. 从T中选取一个其距离值为最小的顶点W且不在S中,加入S
3. 对T中顶点的距离值进行修改:若加进W作中间顶点,从V0到Vi的
距离值比不加W的路径要短,则修改此距离值
重复上述步骤2、3,直到S中包含所有顶点,即S=T为止
#include"stdio.h" #include"string.h" #define INF 999999 int map[201][201],mark[201]; int n,m,s,e,f[201]; void dijkstra() { int i,j,k,min; memset(mark,0,sizeof(mark)); for(i=0;i<n;i++) f[i]=map[s][i]; f[s]=0; for(i=0;i<n;i++) { min=INF; for(j=0;j<n;j++) { if(!mark[j]&&min>f[j]) { k=j; min=f[j]; } } if(min==INF)break; mark[k]=1; for(j=0;j<n;j++) if(!mark[j]&&f[j]>f[k]+map[k][j]) f[j]=map[k][j]+f[k]; } if(f[e]!=INF) printf("%d\n",f[e]); else printf("-1\n"); } int main() { int a,b,l,i,j; while(scanf("%d%d",&n,&m)!=EOF) { for(i=0;i<n;i++) for(j=0;j<n;j++) map[i][j]=INF; for(i=0;i<m;i++) { scanf("%d%d%d",&a,&b,&l); if(map[a][b]>l) map[a][b]=map[b][a]=l; } scanf("%d%d",&s,&e); dijkstra(); } return 0; }
第三种解法:Bellman_Ford算法
这个算法也比较好理解,就是不断松弛操作,处理含有负权的路径
对有向图G(V,E),用贝尔曼-福特算法求以Vs为源点的最短路径的过程:
建立dist[]、Pred[],且dist[s] = 0,其余赋无穷。Pred[]表示某节点路径上的父节点
对(Vi,Vj)属于E,比较dist[Vi] + (Vi,Vj)和dist[Vj],并将小的赋给dist[Vj],如果修改了dist[V_j]则pred[Vj] = Vi(松弛操作)
重复以上操作V ? 1次
再重复操作一次,如dist[Vj] > dist[Vi] + (Vi,Vj),则此图存在负权环。
#include<stdio.h> #define MAX 1047483647 int m,n,d[208],start,tar; struct project{ int x,y,w; }map[2008]; void Bellman_Ford() { int i,j; for(i=0;i<n;i++)//Init d[i]=MAX; d[start]=0; for(i=0;i<n;i++) for(j=0;j<2*m;j++) { if(d[map[j].x]>d[map[j].y]+map[j].w)//relax x --w--> y d[map[j].x]=d[map[j].y]+map[j].w; } if(d[tar]<MAX) printf("%d\n",d[tar]); else printf("-1\n"); } int main() { int i; while(scanf("%d%d",&n,&m)!=EOF) { for(i=0;i<m;i++) { scanf("%d%d%d",&map[i].x,&map[i].y,&map[i].w);//two way road ---> one way road map[i+m].y=map[i].x; map[i+m].x=map[i].y; map[i+m].w=map[i].w; } scanf("%d%d",&start,&tar); Bellman_Ford(); } return 0; }
第四种解法:SPFA算法
这种算法可以说是Bellman_Ford算法的优化,就是在Bellman_Ford算法的基础上加上队列实现,
SPFA(Shortest Path Faster Algorithm)
算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素,并对所有与他相邻的点进行松弛,若某个相邻的点松弛成功,则将其入队。 直到队列为空时算法结束。
这个算法,简单的说就是队列优化的bellman-ford,利用了每个点不会更新次数太多的特点发明的此算法
SPFA——Shortest Path Faster Algorithm,它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径,可以处理负边。SPFA的实现甚至比Dijkstra或者Bellman_Ford还要简单:
设Dist代表S到I点的当前最短距离,Fa代表S到I的当前最短路径中I点之前的一个点的编号。开始时Dist全部为+∞,只有Dist[S]=0,Fa全部为0。
维护一个队列,里面存放所有需要进行迭代的点。初始时队列中只有一个点S。用一个布尔数组记录每个点是否处在队列中。
每次迭代,取出队头的点v,依次枚举从v出发的边v->u,设边的长度为len,判断Dist[v]+len是否小于Dist[u],若小于则改进Dist[u],将Fa[u]记为v,并且由于S到u的最短距离变小了,有可能u可以改进其它的点,所以若u不在队列中,就将它放入队尾。这样一直迭代下去直到队列变空,也就是S到所有的最短距离都确定下来,结束算法。若一个点入队次数超过n,则有负权环。
SPFA 在形式上和宽度优先搜索非常类似,不同的是宽度优先搜索中一个点出了队列就不可能重新进入队列,但是SPFA中一个点可能在出队列之后再次被放入队列,也就是一个点改进过其它的点之后,过了一段时间可能本身被改进,于是再次用来改进其它的点,这样反复迭代下去。设一个点用来作为迭代点对其它点进行改进的平均次数为k,有办法证明对于通常的情况,k在2左右。
SPFA算法(Shortest Path Faster Algorithm),也是求解单源最短路径问题的一种算法,用来解决:给定一个加权有向图G和源点s,对于图G中的任意一点v,求从s到v的最短路径。 SPFA算法是Bellman-Ford算法的一种队列实现,减少了不必要的冗余计算,他的基本算法和Bellman-Ford一样,并且用如下的方法改进: 1、第二步,不是枚举所有节点,而是通过队列来进行优化 设立一个先进先出的队列用来保存待优化的结点,优化时每次取出队首结点u,并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作,如果v点的最短路径估计值有所调整,且v点不在当前的队列中,就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作,直至队列空为止。 2、同时除了通过判断队列是否为空来结束循环,还可以通过下面的方法: 判断有无负环:如果某个点进入队列的次数超过V次则存在负环(SPFA无法处理带负环的图)。
SPFA算法有两个优化算法 SLF 和 LLL
SLF:Small Label First 策略,设要加入的节点是j,队首元素为i,若dist(j)<dist(i),则将j插入队首,否则插入队尾。 LLL:Large Label Last 策略,设队首元素为i,队列中所有dist值的平均值为x,若dist(i)>x则将i插入到队尾,查找下一元素,直到找到某一i使得dist(i)<=x,则将i出对进行松弛操作。 SLF 可使速度提高 15 ~ 20%;SLF + LLL 可提高约 50%。 在实际的应用中SPFA的算法时间效率不是很稳定,为了避免最坏情况的出现,通常使用效率更加稳定的Dijkstra算法。
算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素,并对所有与他相邻的点进行松弛,若某个相邻的点松弛成功,则将其入队。 直到队列为空时算法结束。
这个算法,简单的说就是队列优化的bellman-ford,利用了每个点不会更新次数太多的特点发明的此算法
SPFA——Shortest Path Faster Algorithm,它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径,可以处理负边。SPFA的实现甚至比Dijkstra或者Bellman_Ford还要简单:
设Dist代表S到I点的当前最短距离,Fa代表S到I的当前最短路径中I点之前的一个点的编号。开始时Dist全部为+∞,只有Dist[S]=0,Fa全部为0。
维护一个队列,里面存放所有需要进行迭代的点。初始时队列中只有一个点S。用一个布尔数组记录每个点是否处在队列中。
每次迭代,取出队头的点v,依次枚举从v出发的边v->u,设边的长度为len,判断Dist[v]+len是否小于Dist[u],若小于则改进Dist[u],将Fa[u]记为v,并且由于S到u的最短距离变小了,有可能u可以改进其它的点,所以若u不在队列中,就将它放入队尾。这样一直迭代下去直到队列变空,也就是S到所有的最短距离都确定下来,结束算法。若一个点入队次数超过n,则有负权环。
SPFA 在形式上和宽度优先搜索非常类似,不同的是宽度优先搜索中一个点出了队列就不可能重新进入队列,但是SPFA中一个点可能在出队列之后再次被放入队列,也就是一个点改进过其它的点之后,过了一段时间可能本身被改进,于是再次用来改进其它的点,这样反复迭代下去。设一个点用来作为迭代点对其它点进行改进的平均次数为k,有办法证明对于通常的情况,k在2左右。
SPFA算法(Shortest Path Faster Algorithm),也是求解单源最短路径问题的一种算法,用来解决:给定一个加权有向图G和源点s,对于图G中的任意一点v,求从s到v的最短路径。 SPFA算法是Bellman-Ford算法的一种队列实现,减少了不必要的冗余计算,他的基本算法和Bellman-Ford一样,并且用如下的方法改进: 1、第二步,不是枚举所有节点,而是通过队列来进行优化 设立一个先进先出的队列用来保存待优化的结点,优化时每次取出队首结点u,并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作,如果v点的最短路径估计值有所调整,且v点不在当前的队列中,就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作,直至队列空为止。 2、同时除了通过判断队列是否为空来结束循环,还可以通过下面的方法: 判断有无负环:如果某个点进入队列的次数超过V次则存在负环(SPFA无法处理带负环的图)。
SPFA算法有两个优化算法 SLF 和 LLL
SLF:Small Label First 策略,设要加入的节点是j,队首元素为i,若dist(j)<dist(i),则将j插入队首,否则插入队尾。 LLL:Large Label Last 策略,设队首元素为i,队列中所有dist值的平均值为x,若dist(i)>x则将i插入到队尾,查找下一元素,直到找到某一i使得dist(i)<=x,则将i出对进行松弛操作。 SLF 可使速度提高 15 ~ 20%;SLF + LLL 可提高约 50%。 在实际的应用中SPFA的算法时间效率不是很稳定,为了避免最坏情况的出现,通常使用效率更加稳定的Dijkstra算法。
#include<stdio.h>//SPFA 模拟队列实现最短路径 #include<string.h> #define INF 100000 int map[210][210],flag[210],Q[210],d[210]; int m,n,start,tar; void SPFA() { int i,x; int front=0,rear=0; memset(Q,0,sizeof(Q)); memset(flag,0,sizeof(flag)); for(i=0;i<n;i++) d[i]=INF; d[start]=0; Q[rear]=start; rear++; flag[start]=1; while(front<rear) { x=Q[front];//出队列 front=(front+1)%210; flag[x]=0; for(i=0;i<n;i++) { if(d[i]>d[x]+map[x][i]) { d[i]=d[x]+map[x][i]; if(!flag[i]) { Q[rear]=i;//入队列 rear=(rear+1)%210; flag[i]=1; } } } } if(d[tar]<INF) printf("%d\n",d[tar]); else printf("-1\n"); } int main() { int i,j,a,b,c; while(scanf("%d%d",&n,&m)!=EOF) { for(i=0;i<n;i++) for(j=0;j<n;j++) map[i][j]=INF; for(i=0;i<m;i++) { scanf("%d%d%d",&a,&b,&c); if(map[a][b]>c) map[a][b]=map[b][a]=c; } scanf("%d%d",&start,&tar); SPFA(); } return 0; }
其实最短路总结就一句话,不断的进行松弛操作,无论是什么解法,都要进行松弛操作,然后找到最短路径