SPFA算法

【算法流程】

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

这个算法，简单的说就是队列优化的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无法处理带负环的图）。

松弛

每次松弛操作实际上是对相邻节点的访问，第n次松弛操作保证了所有深度为n的路径最短。由于图的最短路径最长不会经过超过V-1条边，所以可知贝尔曼-福特算法所得为最短路径。

负权环判定

因为负权环可以无限制的降低总花费，所以如果发现第n次操作仍可降低花销，就一定存在负权环。

【算法优化】

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

======================================================================================

SPFA最常用的优化是SLF优化，将队列用双端队列实现。我们就写SLF的优化版本当模板。

首先是邻接矩阵建图的版本：

#include<cstdio>

#include<cstring>

#include<deque>

using namespace std;

const int N = 200;

const int inf = 0x7fffffff;

int g[N][N] , n , m , d[N];

bool SPFA( int s , int e )

{

      int v , cnt[N] = {0};

      bool in_q[N] = {false};

      for( int i = 0 ; i < n ; d[i++] = inf );

      deque<int> q;

      q.push_back(s);

      d[s] = 0;cnt[s]++;in_q[s] = true;

      while(!q.empty())

      {

            v = q.front();q.pop_front();

            for( int i = 0 ; i < n ; i++ )

                  if( g[v][i] < inf && d[v]+g[v][i] < d[i] )

                  {

                        d[i] = d[v]+g[v][i];

                        if( !in_q[i] )

                        {

                              in_q[i] = true;cnt[i]++;

                              if( cnt[i] > n )      return false;

                              if( !q.empty() && d[i] > d[q.front()] )

                                    q.push_back(i);

                              else      q.push_front(i);

                        }

                  }

            in_q[v] = false;

      }

      return d[e]==inf?false:true;

}

int main()

{

      int a , b , c;

      while( ~scanf("%d%d",&n,&m) )

      {

            for( int i = 0 ; i < n ; i++ )

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

                        g[i][j] = g[j][i] = inf;

            for( int i = 0 ; i < m ; i++ )

            {

                  scanf("%d%d%d",&a,&b,&c);

                  if( g[a][b] > c ) g[a][b] = g[b][a] = c;

            }

            scanf("%d%d",&a,&b);

            printf("%d\n",SPFA(a,b)?d[b]:-1 );

      }

      return 0;

}

======================================================================================

再写个邻接表的版本， 但是这里要注意，dijkstra的邻接表版本虽然也是建了图难改，但是在算法内部消除了重边的影响。在写SPFA时我却始终没有很满意的办法在算法内部消除重边，只好在建图时做。

#include<cstdio>

#include<cstring>

#include<deque>

#include<vector>

using namespace std;

const int N = 200;

const int inf = 0x7fffffff;

struct edge

{

      edge( int V , int C ):v(V),c(C){}

      int v , c;

};

vector<edge> g[N];

int n , m , d[N];

bool SPFA( int s , int e )

{

      int v , cnt[N] = {0};

      bool in_q[N] = {false};

      for( int i = 0 ; i < n ; d[i++] = inf );

      deque<int> q;

      q.push_back(s);

      d[s] = 0;cnt[s]++;in_q[s] = true;

      while(!q.empty())

      {

            v = q.front();q.pop_front();

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

            {

                  int u = g[v][i].v , c = g[v][i].c;

                  if( d[v]+c < d[u] )

                  {

                        d[u] = d[v]+c;

                        if( !in_q[u] )

                        {

                              in_q[u] = true;cnt[u]++;

                              if( cnt[u] > n )      return false;

                              if( !q.empty() && d[u] > d[q.front()] )

                                    q.push_back(u);

                              else      q.push_front(u);

                        }

                  }

            }

            in_q[v] = false;

      }

      return d[e]==inf?false:true;

}

int main()

{

      int a , b , c;

      bool in;

      while( ~scanf("%d%d",&n,&m) )

      {

            for( int i = 0 ; i < n ; i++ ) g[i].clear();

            for( int i = 0 ; i < m ; i++ )

            {

                  scanf("%d%d%d",&a,&b,&c);

                  in = true;

                  for( int j = 0 ; j < g[a].size() ; j++ )

                        if( g[a][j].v == b )

                        {

                              in = false;

                              if( g[a][j].c > c ) in = true;

                              break;

                        }

                  if( in )

                  {

                        g[a].push_back(edge(b,c));

                        g[b].push_back(edge(a,c));

                  }

            }

            scanf("%d%d",&a,&b);

            printf("%d\n",SPFA(a,b)?d[b]:-1 );

      }

      return 0;

}