最短路之SPFA算法

计算最短路用Floyd的复杂度太高了，有什么办法可以优化一下呢，我们可以看到Floyd的很大一部分开销花在了计算其他不需要的的路径长度上，如果我只需要计算一个点到另一个点的距离，有没有什么方法呢？
答案就是将Bellman-Ford进行优先队列优化这就是SPFA算法
这个算法是1994年西安交通大学段凡丁提出的，很奇怪Floyd提出这么长时间居然没有人提出用队列进行优化
算法第一步：首先用一个二维vector建立一个无向图，每条边的长度初始化为INF
第二步：将每个点和每条边输入
第三步：初始化一个队列，输入起始点和终点，从起点开始遍历，将遍历到的每个点放入queue，假如a到b的距离原来为c，但图中储存着一个点map[a][b]=d,,如果d能够缩短a到b的距离（a < b），就将这个点的距离缩短为c.
第四步：重复循环上述操作，当操作到重点是结束，或者当队列为空时结束（不存在最短路）
这种方法的最坏情况需要O(NM)，但相比于Floyd来说已经优化了很多，因为很难遇到需要遍历全部点和边的情况
但最重要的是，SPFA能够解决边权是负数的情况，解决方法为判断这个点进入队列的次数是否超过N次，如果超过N次，也就是说它能够N次优化两个点之间的距离，也就是一个点如果是正数，不可能将图中的每一个点有优化，除非是负边权

附上AC代码：

//spfa就是基于Bellman-Ford的队列优化
/*
时间复杂度：最坏O(NM)
适用情况：稀疏图，和边关系密切
可以解决负权
*/
#include<bits/stdc++.h>
using namespace std;
const int maxn =1e3+5;

int d[maxn],inq[maxn];
vector<pair<int,int> >E[maxn];

void init(){
    for(int i=0;i<maxn;i++) E[i].clear();
    for(int i=0;i<maxn;i++) d[i]=1e9;
    for(int i=0;i<maxn;i++) inq[i]=0;
}

int main()
{
    int n,m;
    while(cin>>n>>m) {
            init();
        for(int i=0;i<m;i++) {
            int x,y,s;
            cin>>x>>y>>s;
            E[x].push_back(make_pair(y,s));
            E[y].push_back(make_pair(x,s));
        }
        int s,t;
        cin>>s>>t;
        queue<int>Q;
        Q.push(s),d[s]=0,inq[s]=1;
        while(!Q.empty()) {
            int x=Q.front();Q.pop();inq[x]=0;
            for(int i=0;i<E[x].size();i++) {
                int y=E[x][i].first,l=E[x][i].second;
                if(d[y]>d[x]+l) {
                    d[y]=d[x]+l;
                    if(inq[y]==1) continue;
                    inq[y]=1;
                    Q.push(y);
                }
            }
        }
        if(d[t]==1e9) cout<<-1<<endl;
        else cout<<d[t]<<endl;
    }
    return 0;
}