SPFA

算法训练-最短路径

适用范围：给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又过高，SPFA算法便派上用场了。 我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路，但这不是我们讨论的重点。

算法思想：我们用数组d记录每个结点的最短路径估计值，用邻接表来存储图G。我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止

期望的时间复杂度O(ke)， 其中k为所有顶点进队的平均次数，可以证明k一般小于等于2。

实现方法：
　　建立一个队列，初始时队列里只有起始点，再建立一个表格记录起始点到所有点的最短路径（该表格的初始值要赋为极大值，该点到他本身的路径赋为0）。然后执行松弛操作，用队列里有的点作为起始点去刷新到所有点的最短路，如果刷新成功且被刷新点不在队列中则把该点加入到队列最后。重复执行直到队列为空。

判断有无负环：
　　如果某个点进入队列的次数超过N次则存在负环（SPFA无法处理带负环的图）

实现代码及注释：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;
#define MAX 200001
#define INF 99999999    //表示无穷大
typedef struct XNode
{
    int pow;
    int adjvex;
    struct XNode *next;
}Node;
Node *head[MAX];
int visit[MAX], dis[MAX];
//邻接表存储图
void add(int u, int v, int w)
{
    Node *p;
    p = (Node*)malloc(sizeof(Node));
    p->pow = w;
    p->adjvex = v;
    p->next = head[u];
    head[u] = p;
}

//SPFA算法
void SPFA(int n)
{
    int u, v, w;
    queue<int> Q;
    Node *p;
    for(int i=1; i<=n; i++)
    {
        visit[i] = 0;       //初始化，未进队列的标记为0
        dis[i] = INF;       //初始化为无穷大
    }
    Q.push(1);      //起点入队列
    dis[1] = 0;
    visit[1] = 1;
    while(!Q.empty())
    {
        u = Q.front();      //取head
        Q.pop();        //head出队列
        for(p=head[u]; p!=NULL; p=p->next)      //找到与u相连的点
        {
            v = p->adjvex;      
            w = p->pow;
            //松弛操作
            if(dis[u]+w < dis[v])
            {
                dis[v] = dis[u] + w;
                if(!visit[v])
                {
                    visit[v] = 1;
                    Q.push(v);
                }
            }
        }
    }
}

int main()
{
    int n, m, v1, v2, w;
    memset(head, NULL, sizeof (head));
    cin >> n >> m;
    for(int i=1; i<=m; i++)
    {
        cin >> v1 >> v2 >> w;
        add(v1, v2, w);
    }
    SPFA(n);
    for(int i=2; i<=n; i++)
    {
        cout << dis[i] << endl;
    }
    return 0;
}