HDU-2544-最短路模板题（SPFA)(dijisktra)

最短路

Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 62569 Accepted Submission(s): 27401

Problem Description
在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？

Input
输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，每行包括3个整数A，B，C（1<=A,B<=N,1<=C<=1000）,表示在路口A与路口B之间有一条路，我们的工作人员需要C分钟的时间走过这条路。
输入保证至少存在1条商店到赛场的路线。

Output
对于每组输入，输出一行，表示工作人员从商店走到赛场的最短时间

Sample Input
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0

Sample Output
3
2

解题思路：这道题就是一道最短路径问题，用狄克斯特拉算法就好，狄克斯特拉算法是用来求某一个点到其他各顶点的最短路径，算法思想是第一步集合S中只包含源点v,集合U中包含除源点以外的其他各顶点，第二步是从集合U中选出一个顶点u，到v的距离最小，然后把u加入到集合S中，第三步以u为中间点，修改v到U中各顶点的距离，重复第二补和第三步，直至S 中包含所有顶点。

解题代码：

#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
int n,m;
int Map[105][105];//表示顶点i到顶点j的距离（时间）
void Dijkstra(int v)
{
    int dist[105];//用来表示v点到其他各顶点的距离
    int path[105];//保存路径的，此题没有用到
    int vis[105];//用来标记顶点是否已经在集合U中
    int mindis,u;
    for(int i=1;i<=n;i++)//对dist数组进行赋初值
    {
        dist[i]=Map[v][i];
        vis[i]=0;//初始时所有顶点都不在集合U中
        if(Map[v][i]<0x3f3f3f)
        {
            path[i]=v;
        }
        else
            path[i]=-1;
    }
    vis[v]=1;//把v加到集合U中
    path[v]=0;
    for(int i=1;i<=n;i++)
    {
        mindis=0x3f3f3f;
        for(int j=1;j<=n;j++)//找到到v点距离最近的顶点
        {
            if(vis[j]==0&&dist[j]<mindis)
            {
                u=j;
                mindis=dist[j];
            }
        }
        vis[u]=1;//将u加到集合U中
        for(int j=1;j<=n;j++)//n次循环,让所有顶点加入到集合U中
        {
            if(vis[j]==0)//判断顶点是否已属于集合U
            {
                if(Map[u][j]<0x3f3f3f&&dist[u]+Map[u][j]<dist[j])//以v作为中间点，修改距离
                {
                    dist[j]=dist[u]+Map[u][j];
                    path[j]=u;
                }
            }
        }
    }
    cout<<dist[n]<<endl;
}
int main()
{
    int a,b,c;
    while(scanf("%d%d",&n,&m),(n||m))
    {
        memset(Map,0x3f3f3f,sizeof(Map));//初始时赋为无穷大
        for(int i=1;i<=n;i++)
            Map[i][i]=0;//顶点到自身的距离为0
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            Map[a][b]=c;
            Map[b][a]=c;
        }
        Dijkstra(1);
    }
    return 0;
}
//SPFA算法
#include<bits/stdc++.h>
using namespace std;
vector<int> v[1005];
queue<int> Q;
int n,m,source,endi;
int Map[1005][1005];
int dis[1005];
bool vis[1005];
bool SPFA()
{
    memset(vis,false,sizeof(vis));
    memset(dis,0x3f3f3f,sizeof(dis));
    dis[source]=0;
    Q.push(source);
    int u;
    vis[source]=true;
//cout<<"1"<<endl;
    while(!Q.empty())
    {
        u=Q.front();
        Q.pop();
        vis[u]=false;
        for(int i=0;i<v[u].size();i++)
        {
            int e=v[u][i];
            if(dis[e]>dis[u]+Map[u][e])
            {
                dis[e]=dis[u]+Map[u][e];
                if(vis[e]==false)
                {
                    Q.push(e);
                    vis[e]=true;
                }
            }
        }
    }
    return true;
}
int main()
{
    while(~scanf("%d%d",&n,&m)&&(n||m))
    {
        source=1;
        endi=n;
        int s,t,value;
        memset(Map,0x3f3f3f,sizeof(Map));
        for(int i=1;i<=m;i++)
        {

            scanf("%d%d%d",&s,&t,&value);
            v[s].push_back(t);
            v[t].push_back(s);
            Map[s][t]=value;
            Map[t][s]=value;
        }
        SPFA();
        printf("%d\n",dis[endi]);
    }

    return 0;
}