Bellman-ford算法学习与SPFA算法
来源:互联网 发布:热血传奇蛮王数据 编辑:程序博客网 时间:2024/06/07 05:51
用途:1.判断负权环。
2.在存在负权边的情况下计算单源最短路径
时间复杂度约为O(nm)
可用队列优化,队列实现:SPFA,时间复杂度O(kE)
伪代码(转自nocow):
设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算法有两个优化算法 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算法。
基本C++(nocow)
boolRelax(long&w,longm){returnm<w?(w=m,1):0;}//"松弛"操作constlongmaxV=1000,maxE=999000;//最大顶点数,最大边数longm,H[maxV],D[maxV];//m为边数,初始化为0;H为链表头,初始化为-1;D为距离structEdge{longz,y,w;}E[maxE];//静态邻接表,w为权,y为边终点,z为静态指针voidaddE(longx,longy,longw){E[m].y=y,E[m].w=w,E[m].z=H[x],H[x]=m++;}//加一条从x指向y,权为w的边#include<cstring>#include<queue>voidSPFA(longx=0){//默认计算从0点出发到达其他点的最短路boolF[maxV]={};//初始为0的bool数组表示在不在队内std::queue<long>Q;//初始空队列for(memset(D,0x3f,sizeof(D)),D[x]=0,F[x]=1,Q.push(x);!Q.empty();F[x]=0,Q.pop())//迭代到队列再次变空for(longi=H[x=Q.front()],y;~i;i=E[i].z)//对于所有与x相邻的边if(Relax(D[y=E[i].y],E[i].w+D[x])&&!F[y])F[y]=1,Q.push(y);//如果松弛成功,则要确保y已入队}--------------------------------------------------------------------------------
SPFA(slf优化)
void Spfa(){ d[S]=0; v[S]=true; deque <int> q; for(q.push_back(S);!q.empty();) { int x=q.front(); q.pop_front(); for(int k=head[x];k!=-1;k=el[k].next) { int y=el[k].y; if(d[y]>d[x]+el[k].c) { d[y]=d[x]+el[k].c; if(!v[y]) { v[y]=true; if(!q.empty()) { if(d[y]>d[q.front()]) q.push_back(y); else q.push_front(y); } else q.push_back(y); } } } v[x]=false; } return ;}--------------------------------------------------------------------------------
注释版本
/* * 单源最短路算法SPFA,时间复杂度O(kE),k在一般情况下不大于2,对于每个顶点使用可以在O(VE)的时间内算出每对节点之间的最短路 * 使用了队列,对于任意在队列中的点连着的点进行松弛,同时将不在队列中的连着的点入队,直到队空则算法结束,最短路求出 * SPFA是Bellman-Ford的优化版,可以处理有负权边的情况 * 对于负环,我们可以证明每个点入队次数不会超过V,所以我们可以记录每个点的入队次数,如果超过V则表示其出现负环,算法结束 * 由于要对点的每一条边进行枚举,故采用邻接表时时间复杂度为O(kE),采用矩阵时时间复杂度为O(kV^2) */#include<cstdio>#include<vector>#include<queue>#define MAXV 10000#define INF 1000000000 //此处建议不要过大或过小,过大易导致运算时溢出,过小可能会被判定为真正的距离 using std::vector;using std::queue; struct Edge{int v; //边权int to; //连接的点}; vector<Edge> e[MAXV]; //由于一般情况下E<<V*V,故在此选用了vector动态数组存储,也可以使用链表存储int dist[MAXV]; //存储到原点0的距离,可以开二维数组存储每对节点之间的距离int cnt[MAXV]; //记录入队次数,超过V则退出queue<int> buff; //队列,用于存储在SPFA算法中的需要松弛的节点bool done[MAXV]; //用于判断该节点是否已经在队列中int V; //节点数int E; //边数 bool spfa(const int st){ //返回值:TRUE为找到最短路返回,FALSE表示出现负环退出for(int i=0;i<V;i++){ //初始化:将除了原点st的距离外的所有点到st的距离均赋上一个极大值if(i==st){dist[st]=0; //原点距离为0;continue;}dist[i]=INF; //非原点距离无穷大}buff.push(st); //原点入队done[st]=1; //标记原点已经入队cnt[st]=1; //修改入队次数为1while(!buff.empty()){ //队列非空,需要继续松弛int tmp=buff.front(); //取出队首元素for(int i=0;i<(int)e[tmp].size();i++){ //枚举该边连接的每一条边Edge *t=&e[tmp][i]; //由于vector的寻址速度较慢,故在此进行一次优化if(dist[tmp]+(*t).v<dist[(*t).to]){ //更改后距离更短,进行松弛操作dist[(*t).to]=dist[tmp]+(*t).v; //更改边权值if(!done[(*t).to]){ //没有入队,则将其入队buff.push((*t).to); //将节点压入队列done[(*t).to]=1; //标记节点已经入队cnt[(*t).to]+=1; //节点入队次数自增if(cnt[(*t).to]>V){ //已经超过V次,出现负环while(!buff.empty())buff.pop(); //清空队列,释放内存return false; //返回FALSE}}}}buff.pop();//弹出队首节点done[tmp]=0;//将队首节点标记为未入队}return true; //返回TRUE} //算法结束 int main(){ //主函数scanf("%d%d",&V,&E); //读入点数和边数for(int i=0,x,y,l;i<E;i++){scanf("%d%d%d",&x,&y,&l); //读入x,y,l表示从x->y有一条有向边长度为lEdge tmp; //设置一个临时变量,以便存入vectortmp.v=l; //设置边权tmp.to=y; //设置连接节点e[x].push_back(tmp); //将这条边压入x的表中}if(!spfa(0)){ //出现负环printf("出现负环,最短路不存在\n");}else{ //存在最短路printf("节点0到节点%d的最短距离为%d",V-1,dist[V-1]);}return 0;}
- Bellman-ford算法学习与SPFA算法
- Bellman-Ford&SPFA算法
- 松弛算法-->Bellman-Ford-->SPFA
- Bellman-ford和spfa算法
- Bellman-ford和spfa算法
- Bellman-Ford算法 和 SPFA算法
- bellman-ford算法的优化spfa算法
- Bellman-Ford算法的改进:SPFA算法
- Bellman-ford队列优化算法 SPFA算法
- SPFA算法 (基于Bellman-Ford算法)
- Bellman-Ford算法以及优化(SPFA)
- Bellman-Ford 算法及其优化以及SPFA
- 最短路算法 Dijkstra Bellman-Ford SPFA
- Dijkstra、Bellman-ford、SPFA、Floyd算法
- 单源最短路径--Bellman-Ford算法及SPFA
- Bellman-ford算法 学习笔记
- SPFA 算法的学习--基于Bellman-Ford算法的一种队列实现
- (最短路径算法整理)dijkstra、floyd、bellman-ford、spfa算法模板的整理与介绍
- 边缘检测(2)Roberts算子
- 【拷贝】Eclipse中删除了tomcat后
- putty如何连接到虚拟机下的Linux平台
- HDU 1021Fibonacci Again
- 从KMP算法,trie树再到AC自动机
- Bellman-ford算法学习与SPFA算法
- stringstream的清空问题
- 如何在3个月内拥有3年的工作经验[转]
- 在开发机上运行正常在客户机上崩溃的调试方法
- 那些做了但是没有完成的任务。。。
- 九度OnlineJudge题目1064:反序数
- 深入理解拉格朗日乘子法(Lagrange Multiplier) 和KKT条件
- Java启动新线程的额外开销
- mysql 查看存储过程