【码极客精讲】SPFA算法

SPFA 算法是 Bellman-Ford算法 的队列优化算法的别称，通常用于求含负权边的单源最短路径，以及判负权环。SPFA 最坏情况下时间复杂度和朴素 Bellman-Ford 相同，为 O(VE)。

SPFA算法的全称是：Shortest Path Faster Algorithm，是西南交通大学段凡丁于 1994 年发表的论文中的名字。不过，段凡丁的证明是错误的，且在 Bellman-Ford 算法提出后不久（1957 年）已有队列优化内容，所以国际上不承认 SPFA 算法是段凡丁提出的。

为了避免最坏情况的出现，在正权图上应使用效率更高的Dijkstra算法。

若给定的图存在负权边，类似Dijkstra算法等算法便没有了用武之地，SPFA算法便派上用场了。简洁起见，我们约定加权有向图G不存在负权回路，即最短路径一定存在。用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。

定理：只要最短路径存在，上述SPFA算法必定能求出最小值。证明：每次将点放入队尾，都是经过松弛操作达到的。换言之，每次的优化将会有某个点v的最短路径估计值d[v]变小。所以算法的执行会使d越来越小。由于我们假定图中不存在负权回路，所以每个结点都有最短路径值。因此，算法不会无限执行下去，随着d值的逐渐变小，直到到达最短路径值时，算法结束，这时的最短路径估计值就是对应结点的最短路径值。

实际上，如果一个点进入队列达到n次，则表明图中存在负环，没有最短路径。

段凡丁论文中的复杂度证明 （O(kE)，k 是小常数）是错误的，在此略去。该算法的最坏时间复杂度为 O(VE)。

对SPFA的一个很直观的理解就是由无权图的BFS转化而来。在无权图中，BFS首先到达的顶点所经历的路径一定是最短路(也就是经过的最少顶点数)，所以此时利用数组记录节点访问可以使每个顶点只进队一次，但在带权图中，最先到达的顶点所计算出来的路径不一定是最短路。一个解决方法是放弃数组，此时所需时间自然就是指数级的，所以我们不能放弃数组，而是在处理一个已经在队列中且当前所得的路径比原来更好的顶点时，直接更新最优解。

SPFA算法有四个优化策略：堆优化、栈优化、SLF和LLL。

堆优化：将队列换成堆，与 Dijkstra 的区别是允许一个点多次入堆。在有负权边的图可能被卡成指数级复杂度。

栈优化：将队列换成栈（即将原来的 BFS 过程变成 DFS），在寻找负环时可能具有更高效率，但最坏时间复杂度仍然为指数级。

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 和 LLL 优化在随机数据上表现优秀，但是在正权图上最坏情况为 O(VE)，在负权图上最坏情况为达到指数级复杂度。

伪代码

ProcedureSPFA;
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(Q,v);
        end;
    end;
End; 

C++代码 

#include<iostream>
#include<vector>
#include<list>
using namespace std;
struct Edge
{
    int to,len;
};
bool spfa(const int &beg,//出发点
          const vector<list<Edge> > &adjlist,//邻接表，通过传引用避免拷贝
          vector<int> &dist,//出发点到各点的最短路径长度
          vector<int> &path)//路径上到达该点的前一个点
//没有负权回路返回0
//福利：这个函数没有调用任何全局变量，可以直接复制！
{
    const int INF=0x7FFFFFFF,NODE=adjlist.size();//用邻接表的大小传递顶点个数，减少参数传递
    dist.assign(NODE,INF);//初始化距离为无穷大
    path.assign(NODE,-1);//初始化路径为未知
    list<int> que(1,beg);//处理队列
    vector<int> cnt(NODE,0);//记录各点入队次数，用于判断负权回路
    vector<bool> flag(NODE,0);//标志数组，判断是否在队列中
    dist[beg]=0;//出发点到自身路径长度为0
    cnt[beg]=flag[beg]=1;//入队并开始计数
    while(!que.empty())
    {
        const int now=que.front();
        que.pop_front();
        flag[now]=0;//将当前处理的点出队
        for(list<Edge>::const_iterator//用常量迭代器遍历邻接表
                i=adjlist[now].begin(); i!=adjlist[now].end(); ++i)
            if(dist[i->to]>dist[now]+i->len)//不满足三角不等式
            {
                dist[i->to]=dist[now]+i->len;//更新
                path[i->to]=now;//记录路径
                if(!flag[i->to])//若未在处理队列中
                {
                    if(NODE==++cnt[i->to])return 1;//计数后出现负权回路
                    if(!que.empty()&&dist[i->to]<dist[que.front()])//队列非空且优于队首（SLF）
                        que.push_front(i->to);//放在队首
                    else que.push_back(i->to);//否则放在队尾
                    flag[i->to]=1;//入队
                }
            }
    }
    return 0;
}
int main()
{
    int n_num,e_num,beg;//含义见下
    cout<<"输入点数、边数、出发点：";
    cin>>n_num>>e_num>>beg;
    vector<list<Edge> > adjlist(n_num,list<Edge>());//默认初始化邻接表
    for(int i=0,p; i!=e_num; ++i)
    {
        Edge tmp;
        cout<<"输入第"<<i+1<<"条边的起点、终点、长度：";
        cin>>p>>tmp.to>>tmp.len;
        adjlist[p].push_back(tmp);
    }
    vector<int> dist,path;//用于接收最短路径长度及路径各点
    if(spfa(beg,adjlist,dist,path))cout<<"图中存在负权回路\n";
    else for(int i=0; i!=n_num; ++i)
        {
            cout<<beg<<"到"<<i<<"的最短距离为"<<dist[i]<<"，反向打印路径：";
            for(int w=i; path[w]>=0; w=path[w])cout<<w<<"<-";
            cout<<beg<<'\n';
        }
}

与bfs算法比较，复杂度相对稳定。但在稠密图中复杂度比迪杰斯特拉算法差。

2016年秋季大学先修课考试 F

#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<string>
#include<map>
#include<queue>
#include<stack>
using namespace std;
const int MAXN=200+10;
queue<int>q;
int n,m,p,h[MAXN][MAXN]={0},X,Y;
bool yan[MAXN][MAXN];
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        memset(yan,0,sizeof(yan));
        cin>>n>>m;
        for(int i=1;i<=n;++i)
            for(int j=1;j<=m;++j)
                cin>>h[i][j];
        cin>>X>>Y>>p;
        while(p--)
        {
            int a,b;
            cin>>a>>b;
            q.push(a*MAXN+b);
            yan[a][b]=true;
        }
        while(!q.empty())
        {
            int x=q.front(),y;
            q.pop();
            y=x%MAXN,x/=MAXN;
            if(x+1<=n)
                if(h[x+1][y]<h[x][y])
                    h[x+1][y]=h[x][y],yan[x+1][y]=true,q.push((x+1)*MAXN+y);
            if(x-1>0)
                if(h[x-1][y]<h[x][y])
                    h[x+1][y]=h[x][y],yan[x-1][y]=true,q.push((x-1)*MAXN+y);
            if(y<=m)
                if(h[x][y+1]<h[x][y])
                    h[x][y+1]=h[x][y],yan[x][y+1]=true,q.push(x*MAXN+y+1);
            if(y>0)
                if(h[x][y-1]<h[x][y])
                    h[x][y+1]=h[x][y],yan[x][y-1]=true,q.push(x*MAXN+y-1);
        }
        if(yan[X][Y])
            cout<<"Yes"<<endl;
        else
            cout<<"No"<<endl;
    }
    //system("pause");
    return 0;
}

poj 1502:MPI Maelstrom

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
struct node
{
    int x,y,d,next;
};
int num=0;
node v[11100];
int first[105];
int n;
int q[105];
int f[105];
bool p[105];
int start=1,end=2;
char map[105][5055];
void connect(int x,int y,int d)
{
    num++;
    v[num].x=x;v[num].y=y;v[num].d=d;
    v[num].next=first[x];first[x]=num;
    return; 
}
int main()
{
    int temp;
    int ans=0;
    memset(first,0,sizeof(first));
    memset(q,0,sizeof(q)); q[1]=1;
    memset(f,63,sizeof(f)); temp=f[1];f[1]=0;
    memset(p,false,sizeof(p)); p[1]=true;
    scanf ("%d\n",&n);
    for (int i=1;i<n;i++)
    {
        int x=(i+1),y=1,d=0;
        gets(map[i]);
        for (int j=0;j<strlen(map[i]);j++)
        {
            if (map[i][j]!=' ' && map[i][j]!='x') {d*=10;d+=(map[i][j]-'0');}
            if (map[i][j]==' ' || j==strlen(map[i])-1)
            {
                if (map[i][j-1]!='x' && map[i][j]!='x')
                {
                    connect(y,x,d);
                    connect(x,y,d);
                }
                d=0;y++;
            }
        }
    }
    while (start!=end)
    {
        int x=q[start];
        for (int i=first[x];i!=0;i=v[i].next)
        {
            int y=v[i].y;
            if (f[y]>f[x]+v[i].d)
            {
                f[y]=f[x]+v[i].d;
                if (p[y]==false)
                {
                    q[end]=y;
                    p[y]=true;
                    end++;
                    if (end>n) end=1;
                }
            }
        }
        p[x]=false;
        start++;
        if (start>n) start=1;
    }
    for (int i=1;i<=n;i++)
    {
        if (f[i]!=temp && f[i]>ans) ans=f[i];
    }
    printf ("%d",ans);
    return 0;
}