首页 > 代码库 > spfa算法详解

spfa算法详解

 

program:

#include<cstdio>
using namespace std;
struct node
{int x;
 int value;
 int next;
};
node e[60000];
int visited[1505],dis[1505],st[1505],queue[1000];
int main()
{
  int n,m,u,v,w,start,h,r,cur;
  freopen("c.in","r",stdin);
  freopen("c.out","w",stdout);
  while(scanf("%d%d",&n,&m)!=EOF)
  {
    for(int i=1;i<=1500;i++)
      {visited[i]=0;
       dis[i]=-1;
       st[i]=-1;  //这个初始化给下边那个while循环带来影响
      }
 
   for(int i=1;i<=m;i++)
      {
       scanf("%d%d%d\n",&u,&v,&w);    
       e[i].x=v;            //记录后继节点    相当于链表中的创建一个节点,并使得数据域先记录
       e[i].value=http://www.mamicode.com/w;
       e[i].next=st[u];     //记录顶点节点的某一个边表节点的下标,相当于在链表中吧该边表节点的next指针先指向他的后继边表节点
       st[u]=i;                //把该顶点的指针指向边表节点,相当于链表中的插入中,头结点的指针改变
      }
    start=1;
    visited[start]=1;
    dis[start]=0;
    h=0;
    r=1;
    queue[r]=start;
    while(h!=r)
     {

      h=(h+1)%1000;
      cur=queue[h];
      int tmp=st[cur];
      visited[cur]=0;
    

     while(tmp!=-1)
        {
            if (dis[e[tmp].x]>dis[cur]+e[tmp].value)          
            {
                   dis[e[tmp].x]=dis[cur]+e[tmp].value;
                    if(visited[e[tmp].x]==0)
                      {

                           visited[e[tmp].x]=1;
                           r=(r+1)%1000;
                            queue[r]=e[tmp].x;
                       }
            }
         tmp=e[tmp].next;     
        }
     }
    printf("%d\n",dis[n]);
  }
  return 0;  
}

 

  1. SPFA(Shortest Path Faster Algorithm) [图的存储方式为邻接表]
  2. 是Bellman-Ford算法的一种队列实现,减少了不必要的冗余计算。
  3. 算法大致流程是用一个队列来进行维护。 初始时将源加入队列。 每次从队列中取出一个元素,
  4. 并对所有与他相邻的点进行松弛,若某个相邻的点松弛成功,则将其入队。 直到队列为空时算法结束。
  5. 它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径,可以处理负边。

  6. SPFA 在形式上和BFS非常类似,不同的是BFS中一个点出了队列就不可能重新进入队列,但是SPFA中
  7. 一个点可能在出队列之后再次被放入队列,也就是一个点改进过其它的点之后,过了一段时间可能本
  8. 身被改进,于是再次用来改进其它的点,这样反复迭代下去。

  9. 判断有无负环:如果某个点进入队列的次数超过V次则存在负环(SPFA无法处理带负环的图)。

  10. SPFA算法有两个优化算法 SLF 和 LLL:
  11. SLF:Small Label First 策略,设要加入的节点是j,队首元素为i,若dist(j)<dist(i),则将j插入队首,
  12. 否则插入队尾。
  13. LLL:Large Label Last 策略,设队首元素为i,队列中所有dist值的平均值为x,若dist(i)>x则将i插入
  14. 到队尾,查找下一元素,直到找到某一i使得dist(i)<=x,则将i出对进行松弛操作。
  15. 引用网上资料,SLF 可使速度提高 15 ~ 20%;SLF + LLL 可提高约 50%。
  16. 在实际的应用中SPFA的算法时间效率不是很稳定,为了避免最坏情况的出现,通常使用效率更加稳定的Dijkstra算法。
  17. */ 
  18.  
  19. //用数组实现邻接表存储,pnt[i,0]表示与i相邻的结点个数,pnt[i,1...k]存储与i相邻的点 
  20. int  pnt[MAXN][MAXN]; 
  21. int  map[MAXN][MAXN]; //map[i,j]为初始输入的i到j的距离,并且map[i,i]=0;未知的map[i,j]=INF; 
  22. int  dis[MAXN]; 
  23. char vst[MAXN]; 
  24.  
  25. int SPFA(int n,int s) 
  26.     int i, pri, end, p, t; 
  27.     memset(vst, 0, sizeof(vst)); 
  28.     for (i=1; i<=n; i++) 
  29.         dis[i] = INF; 
  30.     dis[s] = 0; 
  31.     vst[s] = 1; 
  32.     Q[0] = s; pri = 0; end = 1; 
  33.     while (pri < end) 
  34.     { 
  35.         p = Q[pri]; 
  36.         for (i=1; i<=pnt[p][0]; i++) 
  37.         { 
  38.             t = pnt[p][i]; 
  39.             //先释放,释放成功后再判断是否要加入队列 
  40.             if (dis[p]+map[p][t] < dis[t]) 
  41.             { 
  42.                 dis[t] = dis[p]+map[p][t]; 
  43.                 if (!vst[t]) 
  44.                 { 
  45.                     Q[end++] = t; 
  46.                     vst[t] = 1; 
  47.                 } 
  48.             } 
  49.         } 
  50.         vst[p] = 0; 
  51.         pri++; 
  52.     } 
  53.     return 1; 

 

 

 



spfa算法详解