SPFA模板（邻接表）

算法简介
SPFA(Shortest Path Faster Algorithm)是Bellman-Ford算法的一种队列实现，减少了不必要的冗余计算。 它可以在O(kE)的时间复杂度内求出源点到其他所有点的最短路径，可以处理负边。

算法流程
SPFA对Bellman-Ford算法优化的关键之处在于意识到：只有那些在前一遍松弛中改变了距离估计值的点，才可能引起他们的邻接点的距离估计值的改变。因此，算法大致流程是用一个队列来进行维护，即用一个先进先出的队列来存放被成功松弛的顶点。初始时，源点s入队。当队列不为空时，取出队首顶点， 对它的邻接点进行松弛。如果某个邻接点松弛成功，且该邻接点不在队列中，则将其入队。经过有限次的松弛操作后，队列将为空，算法结束。SPFA算法的实现，需要用到一个先进先出的队列queue 和一个指示顶点是否在队列中的标记数组mark。为了方便查找某个顶点的邻接点，图采用临界表存储。

算法代码
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(v);                  

             end;               

           end;

End;

判断负权回路的方案很多，世间流传最广、比较容易实现并且高效的方法的是记录每个结点进队次数，大于等于|V|次表示有负权。

模板（C++）：

#include <vector>
#include <queue>
using namespace std;
#define arraysize 501
int maxData = 0x7fffffff;
typedef struct edge
{
   int to;
   int w;
}edge;
vector<edge> adjmap[arraysize]; //vector实现邻接表
int d[arraysize];
bool final[arraysize];          //记录顶点是否在队列中，SPFA算法可以入队列多次
int cnt[arraysize];             //记录顶点入队列次数
bool SPFA(int s)
{
     queue<int> myqueue;
     int i,j;
     for(i=0;i<n+1;++i)
     {
         d[i] = maxData;        //将除源点以外的其余点的距离设置为无穷大
     }
     memset(final,0,sizeof(final));
     memset(cnt,0,sizeof(cnt));
     d[s]=0;                   //源点的距离为0
     final[s] = true;         
     cnt[s]++;                 //源点的入队列次数增加
     myqueue.push(s);
     int topint;
     while(!myqueue.empty())
     {
         topint = myqueue.front();myqueue.pop();
         final[topint] = false;
         for(i=0;i<adjmap[topint].size();++i)
         {
             int to = adjmap[topint][i].to;
             if(d[topint]<maxData && d[to]>d[topint]+ adjmap[topint][i].w)
             {                                
                  d[to] = d[topint]+ adjmap[topint][i].w;
                  if(!final[to])
                  {
                      final[to] = true;
                      cnt[to]++;
                      if(cnt[to]>=n)   //当一个点入队的次数>=n时就证明出现了负环。
                         return true;
                      myqueue.push(to);
                  }                 
             }
         }
     }
     return false;
}
int main()
{
    for(i=1;i<n+1;++i)       //此处特别注意对邻接表清空
        adjmap[i].clear();
    for(i=0;i<m;++i)         //双向
    {
        cin>>s>>e>>w;
        temp.to = e;
        temp.w = w;
        adjmap[s].push_back(temp);
        temp.to = s;
        adjmap[e].push_back(temp);     
    }
}