算法简介
SPFA(Shortest Path Faster Algorithm)是的一种实现，减少了不必要的冗余计算。
算法流程
算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素，并对所有与他相邻的点进行，若某个相邻的点松弛成功，则将其入队。 直到队列为空时算法结束。 (跟着代码走一遍就懂了)
这个算法，简单的说就是队列优化的bellman-ford,利用了每个点不会更新次数太多的特点发明的此算法
SPFA——Shortest Path Faster Algorithm，它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。SPFA的实现甚至比Dijkstra或者Bellman_Ford还要简单：
设Dist代表S到I点的当前最短距离。开始时Dist全部为+∞，只有Dist[S]=0。
维护一个队列，里面存放所有需要进行迭代的点。初始时队列中只有一个点S。用一个布尔数组记录每个点是否处在队列中。
每次迭代，取出队头的点v，依次枚举从v出发的边v->u，设边的长度为len，判断Dist[v]+len是否小于Dist[u]，若小于则改进Dist[u]，并且由于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算法。
伪代码
Procedure SPFA; Begin initialize-single-source(G,s); initialize-queue(Q); enqueue(Q,s); while not empty(Q) do begin u:=dequeue(Q); for each v∈adj[u] do begin tmp:=d[v]; relax(u,v); if (tmp<>d[v]) and (not v in Q) then enqueue(Q,v); end; end;End;
代码
最基本的SPFA 开始时Dist全部为+∞，只有Dist[S]=0，Fa全部为0。判断Dist[v]+len是否小于Dist[u]，若小于则改进Dist[u]，将Fa[u]记为v，
bool Relax(long &w,long m){return m #include void SPFA(long x=0){//默认计算从0点出发到达其他点的最短路 bool F[maxV]={};//初始为0的bool数组表示在不在队内 std::queue Q;//初始空队列 for(memset(D,0x3f,sizeof(D)),D[x]=0,F[x]=1,Q.push(x);!Q.empty();F[x]=0,Q.pop())//迭代到队列再次变空 for(long i=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 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 ;} procedure spfa;begin fillchar(q,sizeof(q),0); h:=0; t:=0;//队列 fillchar(v,sizeof(v),false);//v[i]判断i是否在队列中 for i:=1 to n do dist[i]:=maxint;//初始化最小值 inc(t); q[t]:=1; v[1]:=true; dist[1]:=0;//这里把1作为源点 while h<>t do begin h:=(h mod n)+1; x:=q[h]; v[x]:=false; for i:=1 to n do if (cost[x,i]>0) and (dist[x]+cost[x,i]
void SPFA(void){ int i; queue list; list.insert(s); for(i=1;i<=n;i++) { if(s==i) continue; dist[i]=map[s][i]; way[i]=s; if(dist[i]) list.insert(i); } int p; while(!list.empty()) { p=list.fire(); for(i=1;i<=n;i++) if(map[p][i]&&(dist[i]>dist[p]+map[p][i]||!dist[i])&&i!=s) { dist[i]=dist[p]+map[p][i]; way[i]=p; if(!list.in(i)) list.insert(i); } }} 模板
/* * 单源最短路算法SPFA,时间复杂度O(kE),k在一般情况下不大于2,对于每个顶点使用可以在O(VE)的时间内算出每对节点之间的最短路 * 使用了队列,对于任意在队列中的点连着的点进行松弛,同时将不在队列中的连着的点入队,直到队空则算法结束,最短路求出 * SPFA是Bellman-Ford的优化版,可以处理有负权边的情况 * 对于负环,我们可以证明每个点入队次数不会超过V,所以我们可以记录每个点的入队次数,如果超过V则表示其出现负环,算法结束 * 由于要对点的每一条边进行枚举,故采用邻接表时时间复杂度为O(kE),采用矩阵时时间复杂度为O(kV^2) */#include#include #include #define MAXV 10000#define INF 1000000000 //此处建议不要过大或过小,过大易导致运算时溢出,过小可能会被判定为真正的距离using std::vector;using std::queue;struct Edge{ int v; //边权 int to; //连接的点};vector e[MAXV]; //由于一般情况下E<
参考：
版权声明：本文为博主原创文章，未经博主允许不得转载。