最短路算法验证hdu 2544

最短路

HDU - 2544                                                    

在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的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

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#define inf 0x3f3f3f3f
#define nodenum (100 + 5)
#define edgenum (10000 + 5)


using namespace std;
int n, m;
int cnt;
int sum;
int dis[nodenum];
bool vist[nodenum];
struct Map
{
    int u, v, w;
    int next;
}edge[edgenum];
int head[nodenum];
void add(int u, int v, int w)
{
    edge[cnt].u = u;
    edge[cnt].v = v;
    edge[cnt].w = w;
    edge[cnt].next = head[u];
    head[u] = cnt ++;
}
void init()
{
    cnt = 0;
    sum = 0;
    memset(head, -1, sizeof(head));
    memset(edge, 0, sizeof(edge));
    memset(dis, inf, sizeof(dis));
    memset(vist, 0, sizeof(vist));
}
void dijkstra()
{
    dis[1] = 0;
        vist[1] = true;
        for(int i = head[1]; ~i; i = edge[i].next)
            {
                dis[edge[i].v] = edge[i].w;
            }
        for(int i = 1; i <= n-1; i ++)
        {
            int Min = inf;//这里一定要考虑到两点之间不存在路的情况
            int x;
            for(int j = 1; j <= n; j ++)
            {
                if(dis[j] < Min&&!vist[j])
                {
                    x = j;
                    Min = dis[j];
                }
            }
            vist[x] = 1;
            for(int k = 1; k <= n; k ++)
            {
                int wtem = inf;
                int distem;
                for(int s = head[x]; ~s; s = edge[s].next)
                {
                    if(edge[s].v == k)
                        wtem = edge[s].w;
                }
                distem = wtem + dis[x];
                if(!vist[k]&&distem < dis[k])
                    dis[k] = distem;
            }
        }
}

int main()
{
    while(scanf("%d %d", &n, &m) != EOF)
    {
        if(!n&&!m)
            break;
            init();
        for(int i = 0; i < m; i ++)
        {
            int u, v, w;
            scanf("%d %d %d", &u, &v, &w);
            add(u,v,w);
            add(v,u,w);
        }
          if(n == 1)
            {
                printf("0\n");
                continue;
            }
            dijkstra();
        printf("%d\n", dis[n]);
    }

    return 0;
}
该题也可以用邻接表存图

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
#define inf 0x3f3f3f3f
#define nodenum (100 + 5)
#define edgenum (10000 + 5)


using namespace std;
int n, m;
int c[nodenum];
int cnt;
int dis[nodenum];
struct Map
{
    int u, v, w;
    int next;
}edge[edgenum];
queue<int> q;
int head[nodenum];
bool vis[nodenum];
void add(int u, int v, int w)
{
    edge[cnt].u = u;
    edge[cnt].v = v;
    edge[cnt].w = w;
    edge[cnt].next = head[u];
    head[u] = cnt ++;
}
void init()
{
    cnt = 0;
    memset(c,0,sizeof(c));
    memset(head, -1, sizeof(head));
    memset(edge, 0, sizeof(edge));
    memset(dis, inf, sizeof(dis));
    memset(vis, 0, sizeof(vis));
}
int spfa(int x)
{
    q.push(x);
    dis[x] = 0;
    vis[x] = true;
    c[x] ++;
   while(!q.empty())
   {
       int t = q.front();
       q.pop();
       vis[t] = false;
       for(int i = head[t]; ~i; i = edge[i].next)
       {
           if((dis[t] + edge[i].w < dis[edge[i].v]))
            {
                dis[edge[i].v] = dis[t] + edge[i].w;
                if(!vis[edge[i].v])
                {
                    c[edge[i].v] ++;
                    vis[edge[i].v] = true;
                    q.push(edge[i].v);
                    if(c[edge[i].v] > n)
                        return 0;
                }
            }

       }
   }
   return 1;
}

int main()
{
    while(scanf("%d %d", &n, &m) != EOF)
    {
        if(!n&&!m)
            break;
            init();
        for(int i = 0; i < m; i ++)
        {
            int u, v, w;
            scanf("%d %d %d", &u, &v, &w);
            add(u,v,w);
            add(v,u,w);
        }
            spfa(1);
        printf("%d\n", dis[n]);
    }

    return 0;
}

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <queue>
#define inf 0x3f3f3f3f
#define nodenum (100 + 5)
#define edgenum (10000 + 5)

using namespace std;
int Map[nodenum][nodenum];
int n, m;
void init()
{
    memset(Map,inf,sizeof(Map));
    for(int i = 1; i <= n; i ++)
        Map[i][i] = 0;
}
void floyd()
{
    for(int k = 1; k <= n; k ++)
    {
        for(int i = 1; i <= n; i ++)
        {
            for(int j = 1; j <= n; j ++)
            {
                if(Map[i][j] > Map[i][k] + Map[k][j])
                {
                    Map[i][j] = Map[i][k] + Map[k][j];
                }

            }
        }
    }
}

int main()
{
      while(scanf("%d %d", &n, &m) != EOF)
    {
        if(!n&&!m)
            break;
            init();
        for(int i = 0; i < m; i ++)
        {
            int u, v, w;
            scanf("%d %d %d", &u, &v, &w);
            Map[u][v] = w;
            Map[v][u] = w;
        }
            floyd();
        printf("%d\n", Map[1][n]);
    }
    return 0;
}