SPFA算法

SPFA算法

　　本文主要讲解的是SPFA算法（即Bellman-Ford算法的队列优化版）。该算法也是用于一种著名的求解单源最短路的算法。
　　上篇文章，我们详细讲解了Dijkstra算法的原理以及实现。（若没有学过，请先前往学习）多次强调的一点是，Dijkstra算法只适用于正权图的单源最短路。而对于存在权值为负的边的图，我们用的是SPFA(Shortest Path Faster Algorithm)算法（队列优化后的Bellman-Ford）。
　　介绍算法之前，必须要提到的是，含负权的图中最短路不一定存在。显而易见，若一个图中存在一个负环，则最短路不存在。这是我们需要注意的一点。
　　先介绍Bellman-Ford算法。其原理为：连续对图中的每条边进行松弛操作，使每个点i对应的距离d[i]不断接近最短路径值。重复之(n-1)次后，如果还能继续松弛更新，则说明图中有负环，无最短路；否则，就说明最短路求解完成，此时每个点i对应的距离d[i]就已经是源点到点i的最短路径。上述算法思维简单，代码易于编写，如下：

    for(int i = 0; i < n; i++) d[i] = INF;
    d[start] = 0;
    for(int k = 0; k < n-1; k++)
        for(int i = 0; i < m; i++) {
            int x = u[i], y = v[i];
            if(d[x] < INF) d[y] = min(d[y], d[x]+w[i]);
        }

　　很容易看出，Bellman-Ford算法的时间复杂度为O(nm)，效率很低。因此，在使用时我们通常使用一个队列来代替上面的循环检查（即所谓的SPFA算法）。
　　如何实现“队列+松弛操作”呢？初始将源点入队。这里需要一个数组vis[i]来记录点i是否已经在队列中。读取队头u，并将队头u出队（记得清除在队里的标记vis[u]）；将从点u出发的所有边进行松弛操作，若此边到达的点v不在队列中，则将其加入队列。如此循环，直到队列为空时，即完成了最短路的求解。（其实基本上就是BFS的思路）至此，还有最后一个值得注意之处。若给定的图中含有负环，则会陷入死循环中！（这是初学者很容易写错的地方）因此我们需要加以判断，及时推出循环。事实上，图中存在负环的充要条件为：某个点进入队列的次数超过n次。故我们只需用一个数组记录每个点的入队次数即可。
　　其实，用FIFO队列实现的Bellman-Ford算法(即SPFA算法)与用priority_queue优先队列实现的Dijkstra算法有不少相似点，大家可以自己作一比较，以加深对这两个算法的理解。
　　另外，上文中提到：若图中有负环，则最短路不存在。这里指的并不是对于所有点的最短路都不存在。
　　最后，还是以模板题HDU2544为例，链接为http://acm.hdu.edu.cn/showproblem.php?pid=2544。虽然本题中并没有权值为负的边，但由于主要目的是为了演示，这样便于大家与Dijkstra算法进行对比。下面为我写的SPFA算法模板（即HDU2544题解）：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
#define maxn 102
using namespace std;

int firste[maxn], nexte[maxn*maxn], d[maxn];
int n, m, sta, en, cnt;
bool vis[maxn];

struct E {
    int u, v, w;
} edge[maxn*maxn];

queue<int> q;

void Init() {
    memset(firste, 0, sizeof(firste));
    memset(nexte, 0, sizeof(nexte));
    memset(edge, 0, sizeof(edge));
    memset(vis, false, sizeof(vis));
    for(int i = 1; i <= n; i++)
        d[i] = 1e9;
    while(!q.empty()) q.pop();
    sta = 1; en = n;
    cnt = 0;
}

void build(int u, int v, int w) {
    E newe;
    newe.u = u; newe.v = v; newe.w = w;
    edge[++cnt] = newe;
    nexte[cnt] = firste[u];
    firste[u] = cnt;
}

void SPFA() {
    d[sta] = 0;
    q.push(sta);
    vis[sta] = true;
    while(!q.empty()) {
        int x = q.front(); q.pop();
        vis[x] = false;
        for(int i = firste[x]; i; i = nexte[i]) {
            int vt = edge[i].v;
            if(d[vt] > d[x]+edge[i].w) {
                d[vt] = d[x]+edge[i].w;
                if(!vis[vt]) {
                    q.push(vt);
                    vis[vt] = true;
                }
            }
        }
    }
}

int main() {
    while(cin >> n >> m && n) {
        Init();
        int tu, tv, tw;
        for(int t = 1; t <= m; t++) {
            cin >> tu >> tv >> tw;
            build(tu, tv, tw);
            build(tv, tu, tw);
        }
        SPFA();
        cout << d[en] << endl;
    }
    return 0;
}