SPFA

算法思想:

   Bellman-Ford算法的时间复杂度比较高，为O(n3)或O(nm)，原因在于Bellman-Ford算法要递推n次，每次递推，扫描所有的边，在递推n次的过程中很多判断是多余的。SPFA算法（Shortest Path Faster Algorithm）是Bellman-Ford算法的一种队列实现，减少了不必要的冗余判断。

   SPFA算法的大致流程是用一个队列来进行维护。初始时将源点加入队列。每次从队列中取出一个顶点，并对所有与它相邻的顶点进行松弛，若某个相邻的顶点松弛成功，则将其入队。重复这样的过程直到队列为空时算法结束。
SPFA算法，简单地说就是队列优化的bellman-ford算法，是根据“每个顶点的最短距离不会更新次数太多”的特点来进行优化的。SPFA算法可以在O(km)的时间复杂度内求出源点到其他所有顶点的最短路径，并且可以处理负权值边。k为每个顶点入队列的平均次数，可以证明，对于通常的情况，k为2左右。

   与bellman-ford算法类似，SPFA算法也使用dist [i]数组存储源点v0到顶点vi的最短路径长度，用path[i]数组存储最终求得的源点v0到顶点vi的最短路径上顶点vi的前一个顶点的序号。

初始时，dist[v0] = 0，其余元素值均为∞；path[i]均为v0；并将源点v0入队列。SPFA算法的实现过程为：
   (1) 取出队列头顶点v，扫描从顶点v发出的每条边，设每条边的终点为u，边<v, u>的权值为w，如果dist[v] + w < dist[u]，则修改dist[u]为dist[v] + w，修改path[u]为v，若顶点u不在当前队列中，还要将顶点u入队列；如果dist[v] + w < dist[u]不成立，则对顶点u不作任何处理。

   (2) 重复执行步骤(1)直至队列为空。

SPFA算法在形式上和广度优先搜索非常类似，不同的是广度优先搜索中一个顶点出了队列就不可能重新进入队列，但是SPFA中一个顶点可能在出队列之后再次被放入队列，也就是说一个顶点改进过其它的顶点之后，过了一段时间可能本身被改进，于是再次用来改进其它的顶点，这样反复迭代下去。

例：

   利用SPFA算法求图(a)中顶点0到其他各顶点的最短路径长度，并输出对应的最短路径。

   假设数据输入时采用如下的格式进行输入：首先输入顶点个数n，然后输入每条边的数据。每条边的数据格式为：u v w，分别表示这条边的起点、终点和边上的权值。顶点序号从0开始计起。最后一行为-1 -1 -1，表示输入数据的结束。

参考代码：

#include <iostream>
#include <cstring>
#include <queue>

using namespace std;

const int MAXN = 10;//定点最大数
const int INF = 1000000;

struct ArcNode
{
    int to;
    int weight;
    ArcNode* pNext;
    ArcNode()
    {
        to = 0;
        weight = 0;
        pNext = NULL;
    }
};

queue <int> Q;

int n;
int dist[MAXN], path[MAXN];//dist[i]表示源点到顶点i的最短距离，path[i]表示：源点到顶点i的最短路径上前一个顶点
bool inq[MAXN];//inq[i]记录:顶点i是否在队列中

ArcNode* List[MAXN];//出边链表的表头数组，此题表头不存数据。

void SPFA(int v0)
{
    int i, u;
    for(i = 0; i < n; ++i)
    {
        dist[i] = INF;
        path[i] = v0;
        inq[i] = false;
    }
    
    dist[v0] = 0;
    path[v0] = v0;
    Q.push( v0 );

    while( !Q.empty() )
    {
        u = Q.front();
        Q.pop();
        inq[u] = false;

        ArcNode* temp = new ArcNode;
        temp  = List[u]->pNext;
        while( temp != NULL )
        {
            int v = temp->to;
            if(dist[v] > dist[u] + temp->weight)
            {
                dist[v] = dist[u] + temp->weight;
                path[v] = u;
                if(!inq[v])
                {
                    Q.push( v );
                    inq[v] = true;
                }
            }
            temp = temp->pNext;
        }
    }
}

int main()
{
    int i;

    cin>>n;

    int u, v, w;

    for(i = 0; i < n; ++i)
        List[i] = new ArcNode;

    while(cin>>u>>v>>w)
    {
        if(u == -1 && v == -1 && w == -1)
            break;

        ArcNode* temp = new ArcNode;
        temp->to = v;
        temp->weight = w;

        temp->pNext = List[u]->pNext;
        List[u]->pNext = temp;
    }

    SPFA( 0 );

    for(i = 0; i < n; ++i)
    {
        ArcNode* ptr;
        ptr = List[i];
        while(ptr != NULL)
        {
            List[i] = ptr->pNext;
            delete ptr;
            ptr = List[i];
        }
    }


    int shortest[MAXN];
    for(i = 1; i < n; ++i)
    {
        cout<<dist[i]<<"\t";
        memset(shortest, 0, sizeof(shortest));
        int k = 0;
        shortest[k] = i;
        while(path[ shortest[k] ] != 0)
        {
            k++;
            shortest[k] = path[ shortest[k-1] ];
        }
        k++;
        shortest[k] = 0;
        for(int j = k; j > 0; --j)
            cout<<shortest[j]<<" -> ";
        cout<<shortest[0]<<endl;
    }


    return 0;
}