单源最短路径(Bellman-ford, dijkstra , SPFA)介绍

Bellman-Ford算法与另一个非常著名的Dijkstra算法一样,用于求解单源点最短路径问题。Bellman-ford算法除了可求解边权均非负的问题外,还可以解决存在负权边的问题,而Dijkstra算法只能处理边权非负的问题,因此 Bellman-Ford算法的适用面要广泛一些。但是,原始的Bellman-Ford算法时间复杂度为 O(VE),比Dijkstra算法的时间复杂度高,事实上,有多种形式的Bellman-Ford算法的优化实现。这些优化实现在时间效率上得到相当提升,例如近一两年被热捧的SPFA(Shortest-Path Faster Algoithm 更快的最短路径算法)算法的时间效率甚至由于Dijkstra算法

下面将介绍下三种算法:(该算法模板参照NYOJ 115 城市平乱)

Bellman-ford算法(O(VE)):

  

该算法存储数据需要创建图:

例如无向图,

for(int i=1;i<=P;i++){     //创建无向图 

        scanf(“%d%d%d”,&es[i].from,&es[i].to,&es[i].cost);

        es[P+i].from=es[i].to;

        es[P+i].to=es[i].from;

        es[P+i].cost=es[i].cost;       

有向图:

for(int i=1;i<=P;i++) scanf(“%d%d%d”,&es[i].from,&es[i].to,&es[i].cost);

算法模板:

struct Node

{

  int from,to,cost;

}es[MAX];

int d[max];

void short_path(int Q)

{

  for(int i=0;i<=M;i++)dis[i]=inf;

  dis[Q]=0;          

  while(true){

     bool update=false;

     for(int i=1; i<=2*P;i++){

          Node e=es[i]; 

          if(dis[e.from]!=inf && dis[e.to]>e.cost+dis[e.from]){

                    dis[e.to]=e.cost+dis[e.from];

                    prev[e.to]=e.from; //进行路径还原,查找出最短的路径经过那几个点。 

                    update=true;                  

          }        

      } 

     if(!update)break;       

  }

//判断负圈 

for(int j=0;j<M;j++) 

      for(int i=1;i<=2*P;i++){

           Node e=es[i]; 

           if(dis[e.from]!=inf && dis[e.to]>e.cost+dis[e.from]){

                  dis[e.to]=e.cost+dis[e.from];

                  if(i==M-1)return 0;  //当循环第M-1次还进行更新最短路径,说明存在负环           

            }        

 } 

Dijkstra算法用堆优化(O(E)):

创建邻接表

for(int i=1;i<=P;i++){

       int f,t,c;

       scanf(“%d%d%d”,&f,&t,&c);

       Node e;

       e.to=f; e.cost=c;

       G[t].push_back(e);

       e.to=t; e.cost=c;

       G[f].push_back(e);                 

算法模板:

struct Node

{

int to,cost;

};

typedef pair<int,int> A;

vector<Node> G[MAX];

int d[max]

void dijkstra(int Q)

{

  priority_queue<A,vector<A>,greater<A> > que;

  que.push(A(0,Q));       

  while(!que.empty()){          

    A p=que.top();que.pop();

    int v=p.second;

    if(d[v]<p.first)continue;

    for(int i=0;i<G[v].size();i++){

        Node e=G[v][i];

        if(d[e.to]> d[v] + e.cost){

            d[e.to]=d[v]+e.cost;

            que.push(A(d[e.to],e.to));                        

         }                     

    }                                              

  }

}

SPFA算法:

SPFA(Shortest Path Faster Algorithm)是Bellman-Ford算法的一种队列实现,减少了不必要的冗余计算。

算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素,并对所有与他相邻的点进行松弛,若某个相邻的点松弛成功,则将其入队。 直到队列为空时算法结束。

这个算法,简单的说就是队列优化的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算法。

下面是我自己写的模板

复制代码

void Spfa()

{

 for (int i(0); i<num_town; ++i)//初始化

 {

        dis[i] = MAX;

         visited[i] = false;    

 }

 queue<int> Q;

 dis[start] = 0;

 visited[start] = true;

 Q.push(start);

 while (!Q.empty()){

     int temp = Q.front();

     Q.pop();

     for (int i(0); i<num_town; ++i)

     {

        if (dis[temp] + road[temp][i] < dis[i])//存在负权的话,就需要创建一个COUNT数组,当某点的入队次数超过V(顶点数)返回。

        {

           dis[i] = dis[temp] + road[temp][i];

           if (!visited[i])

           {

                   Q.push(i);

                   visited[i] = true;    

            }        

        }            

     }

    visited[temp] = false;            

    }    

}

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