poj 2387最短路 使用SPFA

题意即在求图中N到1的最短路，就在这里我第一次使用了SPFA算法（雾

SPFA算法求单源最短路

即初始化该点到其它个点的数组 D  为一个 ‘ 无穷大’  值

将源点放入队列队首，而后执行以下操作，直到队列为空：

取出队首，遍历与队首点邻接的所有点，记队首为u，另一点为v，

若D[v] > D[u] + w[u,v]，那么就更新D[v]为D[u] + w[u,v]，且当v不在队列中就将其加入队列

最终得到一个源点到其它各点的最短路数组D

当然，这个算法的前提是边权值非负

ac代码如下（重边真是坑）

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;

#define MAXN 1<<20

int mapp[1005][1005];

int SPFA(int b, int e,int N)
{
    int road[1005];
    int inQueue[1005];
    memset(inQueue,0,sizeof(inQueue));
    for(int i=1;i<=N;++i)   road[i]=MAXN;
    road[b] = 0;
    queue<int> spf;
    spf.push(b);
    inQueue[b]=1;
    while(!spf.empty())
    {
        int u = spf.front();
        spf.pop();
        inQueue[u] = 0;
        for(int i=1;i<=N;++i)
            if(mapp[u][i]&&road[i]>road[u]+mapp[u][i])
        {
            road[i]=road[u]+mapp[u][i];
            if(inQueue[i]==0)   { spf.push(i); inQueue[i]=1;}
        }
    }
    return road[e];
}

int main()
{

    int N, T;
    while(cin>>T>>N)
    {
        memset(mapp,0,sizeof(mapp));
        for(int i=1;i<=T;++i)
        {
            int u, v, r;
            cin>>u>>v>>r;
            if(mapp[u][v]==0)  mapp[u][v]=mapp[v][u]=r;             //重边的坑
            else   mapp[u][v]=mapp[v][u]=mapp[v][u]>r?r:mapp[v][u];
        }
        cout<<SPFA(N, 1, N)<<endl;
    }
    return 0;
}