hihocoder1093最短路（SPFA算法）

算法描述：

首先将起始节点入队，然后每次从队列中取出一个节点，更新其邻接点的最短路径值，若有被更新，则检查该邻接点是否在队列中，若不在队列中，则入队。如此循环直到队空时算法结束。

当图中不存在负环时，算法一定会收敛，并能得到所求最短路。原因在于，每次从队列中取出一个节点并更新其邻接点的过程其实都是在向最优解逼近的过程，且只有当有更新的时候才可能向队列增加节点。由于不断的在向最优解逼近，所以到最后一定会达到最优解且不再有节点入队，队列最终为空，算法收敛。SPFA算法与dijkstra相比有一个好处：dijkstra算法不能处理图中有负圈的情况，而在SPFA算法中，只需要记录每个节点入队的次数，若某个节点入队的次数超过了节点总数，那么可判定图中一定存在负圈。

SPFA算法对边数的依赖很强，因此，在实际应用中性能并不是很稳定（相对于dijkstra而言），但是对于稀疏图（边比较少）的情况，SPFA比较优越。

我的代码：

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

using namespace std;

#define MAXN 100005
#define INF 0x7fffffff

struct edge
{
    int y, w;
    edge(int _y, int _w):y(_y),w(_w){}
};

vector<edge> v[MAXN];
int d[MAXN], n, m, s, t;
bool inq[MAXN];

void spfa()
{
    for(int i=1; i<=n; ++i) d[i] = INF;
    d[s] = 0;
    memset(inq+1, 0, n);
    queue<int> q;
    q.push(s);
    inq[s] = true;
    while(!q.empty())
    {
        int x = q.front();
        q.pop();
        inq[x] = false;
        int sz = v[x].size();
        for(int i=0; i<sz; ++i)
        {
            int y = v[x][i].y, w = v[x][i].w;
            if(d[y]>d[x]+w)
            {
                d[y] = d[x]+w;
                if(!inq[y]) q.push(y);
            }
        }
    }
}

int main()
{
    while(cin>>n>>m>>s>>t)
    {
        for(int i=1; i<=n; ++i) v[i].clear();
        while(m--)
        {
            int x, y, w;
            cin>>x>>y>>w;
            v[x].push_back(edge(y, w));
            v[y].push_back(edge(x, w));
        }
        spfa();
        cout<<d[t]<<endl;
    }
    return 0;
}

题目链接：http://hihocoder.com/problemset/problem/1093