最短路 spfa+STL

与迪杰斯特拉相同的是spfa也是用来求单源点的最短路径问题，但是，当问题中的边是有向负边的时候，迪杰斯特拉就无能为力了，

而且给我的感觉是spfa如何结合STL来用的话代码比迪杰斯特拉的还要短一点，只是在思路上会比它稍微复杂一点点。spfa的原理：

同样设置一个数组d[maxn]用来保存源点到各点的距离，初始化为无穷打，同时定义一个队列que，初始化为空，然后还要定义一个数组visit[maxn]，

用来标记当前的某个点是否在队列当中，初始化为false。算法第一步，把源点加入到队列中，然后用源点去更新源点到它可以到达的点的距离，

如果这个源点到这个点的距离可以被更新，而且队列中没有这个点的话，就把这个点加入到队列中。然后继续从队首弹出一个点，然后同理用这个点

去更新其它的点，重复下去直到队列为空，这时结果就出来了。下面是我A的第一个spfa的代码，用邻接表的，小小的纪念一下。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<deque>
using namespace std;

typedef struct node
{
    int d,len;
    node *next;
}Linklist;
typedef struct Node
{
    int tot;
    Linklist *next;
    Node()
    {
        tot = 0;
        next = NULL;
    }
}linklist;
linklist rode[20005];

int d[20005],visit[20005];
void push(int u,int v,int l)
{
    Linklist *q = new Linklist;
    q->d = v;
    q->len = l;
    q->next = NULL;
    rode[u].tot++;
    if(rode[u].next == NULL)
    {
        rode[u].next = q;
        return ;
    }
    Linklist *p = rode[u].next;
    while(p->next)
    p = p->next;
    p->next = q;
}

int main()
{
    int n,m,u,v,l;
    scanf("%d%d",&n,&m);
    for(int i = 0;i < m;++i)
    {
        scanf("%d%d%d",&u,&v,&l);
        push(u,v,l);
    }
    deque<int> que;
    deque<int>::iterator iter;
    que.push_back(1);
    memset(d,0x3f,sizeof(d));
    memset(visit,0,sizeof(visit));
    visit[1] = 1;
    d[1] = 0;
    while(!que.empty())
    {
        int temp = *(que.begin());
        que.pop_front();
        visit[temp] = 0;
        Linklist *p = rode[temp].next;
        while(p)
        {
            if(d[temp] + p->len < d[p->d])
            {
                d[p->d] = d[temp] + p->len;
                if(!visit[p->d])
                {
                    que.push_back(p->d);
                    visit[p->d] = 1;
                }
            }
            p = p->next;
        }
    }
    for(int i = 2;i <= n;++i)
    printf("%d\n",d[i]);
    return 0;
}