Spfa算法

Spfa算法 （模板源代码）

   这是Bellman Ford的改进算法。
   算法介绍：建立一个队列，初始时队列里只有起始点，在建立一个表格记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。然后执行松弛操作，用队列里有的点去刷新起始点到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空。 
   时间复杂度：期望的时间复杂度O(ke)， 其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。

   通用模板设计（源代码）：

先说明一下，g所求有向图（g[i][j]为i到j的边长度，如果g[i][j]不存在，则赋值为-1），Q为队列，dis中所有元素应初始化为inf(0xfffffff最大值),visit中所有元素应初始化为false。

 

void spfa(int s,int m)
{
  int i,k,ts=0,te=1;
  Q[ts] = s;
  dis[s] = 0;
  while(ts<te)
  {
    k =Q[ts];

   visit[k]=false; 
   for(i=1;i<=m;i++)
   {
      if(g[k][i]>0&& dis[i]> dis[k]+g[k][i])
      {
         dis[i] = dis[k] + g[k][i];
         if(!visit[i])
         {
            Q[te++] = i;
            visit[i] = true;
          }
      }
    }
    ts++;
  }
}

void SPFA(int s,int dist[],vector<node>vec[])
{
     unsigned i,x;
  
     for(i=1;i<=p;i++)
     dist[i]=0xfffffff;
     memset(indeque,false,sizeof(indeque));
     dist[s]=0;
     myqueue.push(s);
     indeque[s]=true;
     while(!myqueue.empty())
     {
     x=myqueue.front();
     myqueue.pop();
     indeque[x]=false;
     for(i=0;i<vec[x].size();++i)
     {
       if(dist[vec[x][i].next]>dist[x]+vec[x][i].d)
       {
         dist[vec[x][i].next]=dist[x]+vec[x][i].d;
         if(!indeque[vec[x][i].next])
         {
           myqueue.push(vec[x][i].next);
           indeque[vec[x][i].next]=true;
         }
       }
     }
     }
}

 

其中，得到的dis数组dis[i]就是的源点s到点i的最短路径长度。

值得一提的是，当所求图的点很多时，用二维数组来储存图可能会MLE，这就需要用邻接表或者邻接矩阵来储存图了，只要将该模板稍改一下，就可以用了。不过，学会该算法的思想是最重要的了！

 

关于SPFA算法中的前向星，应该说几句，

head[x]:  表示指向以x为起点的边的序号（0,1,2。。。）

struct EDGE
{
    int link,next;
    __int64 val;
}edge[E],node[V];

题目中给出的m条边保存到 node 数组中

再对node数组操作，通过建图、加边函数，保存到edge数组中，（edge[i].link 表示第i条边的终点，edge[i].next表示第i条边的下一条边的序号，edge[i].val为该边的权值）

加边函数如下：

void addedge(int x,int y,__int64 c)//加边
{
    edge[e].link=y;
    edge[e].val=c;
    edge[e].next=head[x];
    head[x]=e++;
}

void buildgraph()//建图
{
    e=0;
    memset(head,-1,sizeof(head));
    for(int i=0;i<m;i++) addedge(node[i].link,node[i].next,node[i].val);
}

__int64 SPFA(int src,int n)
{
    int u,v;
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=n;i++)  dist[i]=INF;
    dist[src]=0;
    vis[src]=true;
    while(!q.empty())  q.pop();
    q.push(src);
    while(!q.empty())
    {
        u=q.front();
        q.pop();
        vis[u]=false;
        for(int i=head[u];i!=-1;i=edge[i].next)
        {
            int v=edge[i].link;
            if(dist[u]+edge[i].val<dist[v])
            {
                dist[v]=dist[u]+edge[i].val;
                if(!vis[v])
                {
                  q.push(v);
                  vis[v]=true;
                }
            }
        }
    }
    __int64 sum=0;
    for(int i=2;i<=n;i++)
    sum+=dist[i];
    return sum;
}