松弛算法-->Bellman-Ford-->SPFA

2019年3月17日 282次阅读 来源: Bellman - ford算法


松弛操作：

单源最短路径算法中使用了松弛（relaxation）操作。对于每个顶点v∈V，都设置一个属性d[v]，用来描述从源点s到v的最短路径上权值的上界，称为最短路径估计（shortest-path estimate）。π[v]代表S到v的当前最短路径中v点之前的一个点的编号,我们用下面的Θ(V)时间的过程来对最短路径估计和前趋进行初始化。

INITIALIZE-SINGLE-SOURCE(G,s)
1   for each vertex v∈V[G]
2      do d[v]←∞
3         π[v]←NIL
4   d[s]←0

经过初始化以后，对所有v∈V，π[v]=NIL，对v∈V-{s}，有d[s]=0以及d[v]=∞。

在松弛一条边(u,v)的过程中，要测试是否可以通过u，对迄今找到的v的最短路径进行改进；如果可以改进的话，则更新d[v]和π[v]。一次松弛操作可以减小最短路径估计的值d[v]，并更新v的前趋域π[v](S到v的当前最短路径中v点之前的一个点的编号)。下面的伪代码对边(u,v)进行了一步松弛操作。

RELAX(u, v, w)
1   if(d[v]>d[u]+w(u,v))
2      then d[v]←d[u]+w(u,v)
3           π[v]←u

每个单源最短路径算法中都会调用INITIALIZE-SINGLE-SOURCE，然后重复对边进行松弛的过程。另外，松弛是改变最短路径和前趋的唯一方式。各个单源最短路径算法间区别在于对每条边进行松弛操作的次数，以及对边执行松弛操作的次序有所不同。在Dijkstra算法以及关于有向无回路图的最短路径算法中，对每条边执行一次松弛操作。在Bellman-Ford算法中，每条边要执行多次松弛操作。

以上转自 nocow 及 《算法导论》


Bellman-Ford

对有向图G(V,E)，用贝尔曼-福特算法求以Vs为源点的最短路径的过程：

  • 建立dist[]、Pred[],且dist[s] = 0,其余赋《松弛算法-->Bellman-Ford–>SPFA》” />。<span style=Pred[]表示某节点路径上的父节点
  • 对《松弛算法-->Bellman-Ford–>SPFA》” />，比较<span style=dist[Vi] + (Vi,Vj)和dist[Vj],并将小的赋给dist[Vj]，如果修改了dist[V_j]则pred[Vj] = Vi（松弛操作）
  • 重复以上操作V − 1次
  • 再重复操作一次，如dist[Vj] > dist[Vi] + (Vi,Vj),则此图存在负权环。

直接上伪码：

For i:=1 to |V|-1 do //v为顶点数
For 每条边(u,v)∈E do  //对每条边进行遍历
  Relax(u,v,w);
For每条边(u,v)∈E do   //判断是否存在负权环
  If dis[u]+w<dis[v] Then Exit(False)

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算法。

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(slf优化)

pascal:

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]<dist[i]) then
          begin
            dist[i]:=dist[x]+cost[x,i];
            if not(v[i]) then
              begin
                t:=(t mod n)+1;
                q[t]:=i;
                v[i]:=true;
              end;
          end;
    end;
end;

C/C++

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);
    }
 }
}

    原文作者：Bellman - ford算法
    原文地址: https://blog.csdn.net/q175291788/article/details/6892090
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞