单源最短路径 ——SPFA算法

求单源最短路径的SPFA算法在Bellman-Ford算法的基础上进行了改进，使其在能够计算带负权图的单源最短路径的基础上，时间复杂度大幅度降低。

时间复杂度   O(k*e)  k<=2

基本算法：

    设立一个先进先出的队列来保存待优化的节点，优化时每次取出队首节点u，并且用u点当前的最短路径估计值对离开u点所指向的节点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出节点来进行松弛操作，直至队列空为止。这个算法保证只要最短路径存在，SPFA算法必定能求出最小值。

    SPFA算法同样可以判断负环，如果某个点弹出队列的次数超过N-1次，则存在负环。对于存在负环的图，无法计算单源最短路径。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<string.h>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;
#define INF 0x3f3f3f3f
#define maxn 1010
int n,m,k,a,b,c,s,e;
int map[maxn][maxn],pre[maxn],vis[maxn],dist[maxn],lj[maxn];
void spfa(int s)
{
    for(int i=0;i<=n;i++)
    {
        dist[i]=INF;  pre[i]=s;
    }
    dist[s]=0; pre[s]=-1;
    memset(vis,0,sizeof(vis));
    queue<int>q;
    while(!q.empty()) q.pop();
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        vis[u]=0;
        for(int v=1;v<=n;v++)
        {
            if(dist[v]=dist[u]+map[u][v])
            {
                dist[v]=dist[u]+map[u][v];
                pre[v]=u;
                if(!vis[v])
                {
                    vis[v]=1;
                    q.push(v);
                }
            }
        }
    }
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            map[i][j]=INF;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(map[a][b]>c)
                map[a][b]=map[b][a]=c;
        }
        scanf("%d%d",&s,&e);
        spfa(s);
        printf("%d\n",dist[e]);
    }
    return 0;
}