邻接表(spfa算法---单源最短路)

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string.h>
#include <queue>
#include <vector>
#define inf 0x3fffffff                     
#define N 10010
using namespace std;        //使用邻接表hdu2544  （spfa算法----单源最短路）
int pre[210], dis[210], n, m, vis[210], s, e;  //pre[x]记录的是起点为x的链表之首在数组p的位置（相当于头插法）
queue<int> q;
/*
spfa算法做法（百度）：
我们用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。
我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，
优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，
如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。这样不断从队列中取出结点来进行松弛操作，直至队列空为止。
*/
struct Edge
{
    int v; //表示边的终点
    int w; //边的权值
    int next;  //同一个起点的上一个边在数组p里的位置
}p[N];   //注意这里是边的数目
void init()  //初始化邻接表
{
    int t, j, a, b, c, index=0, flag;   //index表示序号
    memset(pre, -1, sizeof(pre));
    for(t=0; t<m; ++t)
    {
        scanf("%d%d%d", &a, &b, &c);
        p[index].v=b;
        p[index].w=c;
        p[index].next=pre[a];
        pre[a]=index;
        index++;
        p[index].v=a;   //路是双向的
        p[index].w=c;
        p[index].next=pre[b];
        pre[b]=index;
        index++;
    }
    return ;
}
void spfa()
{
    int t, g, j;   //起点为1， 终点为end
    s=1;
    e=n;
    for(t=1; t<=n; ++t)
        dis[t]=inf;
    dis[s]=0;
    while(!q.empty())
    {
        q.pop();
    }
    q.push(s);
	vis[s]=1;
    while(!q.empty())
    {
        g=q.front();
        q.pop();
        vis[g]=0;
        for(j=pre[g]; j!=-1; j=p[j].next)
        {
            if(dis[p[j].v]>p[j].w+dis[g])     //最短路径估计值有所改变
            {
                dis[p[j].v]=p[j].w+dis[g];
                if(!vis[p[j].v])      //该节点v不在序列中
               {
                    vis[p[j].v]=1;
                    q.push(p[j].v);
                }
            }
        }
    }
    return ;
}

int main()
{
    while(scanf("%d%d", &n, &m)!=EOF)
    {
        if(n==0&&m==0)break;
        init();  //初始化
        spfa();
        printf("%d\n", dis[n]);
    }
    return 0;
}