最短路 HDU2544（练习模板的好题）

最短路

Time Limit: 5000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)

Total Submission(s): 37479 Accepted Submission(s): 16317

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

SPFA算法SPFA比较简单，这篇文章写的不错

//#include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<string>
#include<queue>
#include<cstring>
using namespace std;
template<class T>inline T read(T&x)
{
    char c;
    while((c=getchar())<=32)if(c==EOF)return -1;
    bool ok=false;
    if(c=='-')ok=true,c=getchar();
    for(x=0; c>32; c=getchar())
        x=x*10+c-'0';
    if(ok)x=-x;
    return 1;
}
template<class T> inline T read_(T&x,T&y)
{
    return read(x)!=-1&&read(y)!=-1;
}
template<class T> inline T read__(T&x,T&y,T&z)
{
    return read(x)!=-1&&read(y)!=-1&&read(z)!=-1;
}
template<class T> inline void write(T x)
{
    if(x<0)putchar('-'),x=-x;
    if(x<10)putchar(x+'0');
    else write(x/10),putchar(x%10+'0');
}
template<class T>inline void writeln(T x)
{
    write(x);
    putchar('\n');
}
//-------ZCC IO template------
const int maxn=101;
const double inf=999999999;
#define lson (rt<<1),L,M
#define rson (rt<<1|1),M+1,R
#define M ((L+R)>>1)
#define For(i,t,n) for(int i=(t);i<(n);i++)
typedef long long  LL;
typedef double DB;
#define bug printf("---\n");
#define mod 10007

int G[maxn][maxn];
bool vis[maxn];
int d[maxn];
int V,E;
void spfa(int s)
{
    For(i,0,V+1)
    {
        vis[i]=false;
        d[i]=inf;
    }
    d[s]=0;
    queue<int> q;
    q.push(s);
    vis[s]=true;
    while(!q.empty())
    {
        int tmp=q.front();q.pop();
        for(int u=1;u<=V;u++)
        {
            if(d[u]>d[tmp]+G[tmp][u])
            {
                d[u]=d[tmp]+G[tmp][u];
                if(!vis[u])
                {
                    q.push(u);
                    vis[u]=true;
                }
            }
        }
        vis[tmp]=false;
    }

}

int main()
{
  //#ifndef ONLINE_JUDGE
   //freopen("in.txt","r",stdin);
 // #endif // ONLINE_JUDGE
    int n,m,i,j,k,t;
    while(read_(V,E)&&(V||E))
    {
        For(i,1,V+1)For(j,1,V+1)G[i][j]=inf;
        for(i=0;i<E;i++)
        {
            int a,b,c;
            read__(a,b,c);
            G[a][b]=c;
            G[b][a]=c;
        }
        spfa(1);
        writeln(d[V]);
    }
    return 0;
}

bell_man  时间O(V*E)

//#include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<string>
#include<cstring>
using namespace std;
template<class T>inline T read(T&x)
{
    char c;
    while((c=getchar())<=32)if(c==EOF)return -1;
    bool ok=false;
    if(c=='-')ok=true,c=getchar();
    for(x=0; c>32; c=getchar())
        x=x*10+c-'0';
    if(ok)x=-x;
    return 1;
}
template<class T> inline T read_(T&x,T&y)
{
    return read(x)!=-1&&read(y)!=-1;
}
template<class T> inline T read__(T&x,T&y,T&z)
{
    return read(x)!=-1&&read(y)!=-1&&read(z)!=-1;
}
template<class T> inline void write(T x)
{
    if(x<0)putchar('-'),x=-x;
    if(x<10)putchar(x+'0');
    else write(x/10),putchar(x%10+'0');
}
template<class T>inline void writeln(T x)
{
    write(x);
    putchar('\n');
}
//-------ZCC IO template------
const int maxn=1000110;
const double inf=999999999;
#define lson (rt<<1),L,M
#define rson (rt<<1|1),M+1,R
#define M ((L+R)>>1)
#define For(i,t,n) for(int i=(t);i<(n);i++)
typedef long long  LL;
typedef double DB;
#define bug printf("---\n");
#define mod 10007

struct edge
{
    int from,to,cost;
}es[maxn];

int V,E;
int d[maxn];
void bell_man(int s)
{
    fill(d,d+V+1,inf);
    d[s]=0;
    while(true)
    {
        bool update=false;
        for(int i=0;i<E;i++)
        {
            edge e=es[i];
            if(d[e.from]!=inf&&d[e.to]>d[e.from]+e.cost)
            {
                d[e.to]=d[e.from]+e.cost;
                update=true;
            }
        }
        if(!update)break;
    }
}

int main()
{
  //#ifndef ONLINE_JUDGE
   //freopen("in.txt","r",stdin);
 // #endif // ONLINE_JUDGE
    int n,m,i,j,k,t;
    while(read_(V,E)&&(V||E))
    {
        E<<=1;
        for(i=0;i<E;i+=2)
        {
            int a,b,c;
            read__(a,b,c);
            es[i].from=a;
            es[i].to=b;
            es[i].cost=c;
            es[i+1].from=b;
            es[i+1].to=a;
            es[i+1].cost=c;
        }
        bell_man(1);
        writeln(d[V]);
    }
    return 0;
}

dijkstra  时间O(V*V)

//#include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<string>
#include<cstring>
using namespace std;
template<class T>inline T read(T&x)
{
    char c;
    while((c=getchar())<=32)if(c==EOF)return -1;
    bool ok=false;
    if(c=='-')ok=true,c=getchar();
    for(x=0; c>32; c=getchar())
        x=x*10+c-'0';
    if(ok)x=-x;
    return 1;
}
template<class T> inline T read_(T&x,T&y)
{
    return read(x)!=-1&&read(y)!=-1;
}
template<class T> inline T read__(T&x,T&y,T&z)
{
    return read(x)!=-1&&read(y)!=-1&&read(z)!=-1;
}
template<class T> inline void write(T x)
{
    if(x<0)putchar('-'),x=-x;
    if(x<10)putchar(x+'0');
    else write(x/10),putchar(x%10+'0');
}
template<class T>inline void writeln(T x)
{
    write(x);
    putchar('\n');
}
//-------ZCC IO template------
const int maxn=101;
const double inf=999999999;
#define lson (rt<<1),L,M
#define rson (rt<<1|1),M+1,R
#define M ((L+R)>>1)
#define For(i,t,n) for(int i=(t);i<(n);i++)
typedef long long  LL;
typedef double DB;
#define bug printf("---\n");
#define mod 10007

int G[maxn][maxn];
bool vis[maxn];
int d[maxn];
int V,E;
void dij(int s)
{
    For(i,0,V+1)
    {
        vis[i]=false;
        d[i]=inf;
    }
    d[s]=0;
    while(true)
    {
        int v=-1;
        For(u,1,V+1) if(!vis[u]&&(v==-1||d[v]>d[u]))
            v=u;
        if(v==-1)break;
        vis[v]=true;
        For(u,1,V+1)
            d[u]=min(d[u],d[v]+G[v][u]);
    }
}

int main()
{
  //#ifndef ONLINE_JUDGE
   //freopen("in.txt","r",stdin);
 // #endif // ONLINE_JUDGE
    int n,m,i,j,k,t;
    while(read_(V,E)&&(V||E))
    {
        For(i,1,V+1)For(j,1,V+1)G[i][j]=inf;
        for(i=0;i<E;i++)
        {
            int a,b,c;
            read__(a,b,c);
            G[a][b]=c;
            G[b][a]=c;
        }
        dij(1);
        writeln(d[V]);
    }
    return 0;
}

dijkstra使用堆优化版 时间O(E log V)

//#include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<string>
#include<queue>
#include<vector>
#include<map>
#include<cstdlib>
#include<set>
#include<stack>
#include<cstring>
using namespace std;
template<class T>inline T read(T&x)
{
    char c;
    while((c=getchar())<=32)if(c==EOF)return -1;
    bool ok=false;
    if(c=='-')ok=true,c=getchar();
    for(x=0; c>32; c=getchar())
        x=x*10+c-'0';
    if(ok)x=-x;
    return 1;
}
template<class T> inline T read_(T&x,T&y)
{
    return read(x)!=-1&&read(y)!=-1;
}
template<class T> inline T read__(T&x,T&y,T&z)
{
    return read(x)!=-1&&read(y)!=-1&&read(z)!=-1;
}
template<class T> inline void write(T x)
{
    if(x<0)putchar('-'),x=-x;
    if(x<10)putchar(x+'0');
    else write(x/10),putchar(x%10+'0');
}
template<class T>inline void writeln(T x)
{
    write(x);
    putchar('\n');
}
//-------ZCC IO template------
const int maxn=101;
const double inf=999999999;
#define lson (rt<<1),L,M
#define rson (rt<<1|1),M+1,R
#define M ((L+R)>>1)
#define For(i,t,n) for(int i=(t);i<(n);i++)
typedef long long  LL;
typedef double DB;
typedef pair<int,int> P;
#define bug printf("---\n");
#define mod 10007

int V,E;
struct edge
{
    int to,cost;
    edge(int a,int b){to=a;cost=b;}
};
vector<edge> G[maxn];
int d[maxn];

void dij_(int s)
{
     priority_queue<P,vector<P>,greater<P> >q;
     fill(d,d+V+1,inf);
     d[s]=0;
     q.push(P(0,s));

     while(!q.empty())
     {
         P v=q.top();
         q.pop();
         if(d[v.second]<v.first)continue;
         for(int i=0;i<G[v.second].size();i++)
         {
             edge tmp=G[v.second][i];
             if(d[tmp.to]>d[v.second]+tmp.cost)
             {
                 d[tmp.to]=d[v.second]+tmp.cost;
                 q.push(P(d[tmp.to],tmp.to));
             }
         }
     }
}

int main()
{
  //#ifndef ONLINE_JUDGE
   //freopen("in.txt","r",stdin);
 // #endif // ONLINE_JUDGE
    int n,m,i,j,k,t;
    while(read_(V,E)&&(V||E))
    {
        For(i,0,E)
        {
            int a,b,c;
            read__(a,b,c);
            G[a].push_back(edge(b,c));
            G[b].push_back(edge(a,c));
        }
        dij_(1);
        writeln(d[V]);
        For(i,0,V+1)G[i].clear();
    }
    return 0;
}
时间： 2024-10-09 11:13:07

最短路 HDU2544（练习模板的好题）的相关文章

POJ 2449 Remmarguts&#39; Date (第k短路 A*搜索算法模板)

Remmarguts' Date Time Limit: 4000MS   Memory Limit: 65536K Total Submissions: 22412   Accepted: 6085 Description "Good man never makes girls wait or breaks an appointment!" said the mandarin duck father. Softly touching his little ducks' head, h

一道模板元编程题源码解答(replace_type)

今天有一同学在群上聊到一个比较好玩的题目(本人看书不多,后面才知是<C++模板元编程>第二章里面的一道习题), 我也抱着试一试的态度去完成它, 这道题也体现了c++模板元编程的基础和精髓: 类型就是数据. 题目如下所述: Write a ternary metafunction replace_type<c,x,y> that takes an arbitrary compound type c as its first parameter, and replaces all oc

最短路+线段交 POJ 1556 好题

1 // 最短路+线段交 POJ 1556 好题 2 // 题意:从(0,5)到(10,5)的最短距离,中间有n堵墙,每堵上有两扇门可以通过 3 // 思路:先存图.直接n^2来暴力,不好写.分成三部分,起点 终点和之间的点:中间点之间:起点和终点的距离 4 // n最大为18所以直接n^3最短路 5 6 7 #include <cstdio> 8 #include <cstring> 9 #include <iostream> 10 #include <algo

最短路 - bellman-ford 算法模板

http://acm.sdut.edu.cn/sdutoj/problem.php?action=showproblem&problemid=2894 谈一下对贝尔曼福特的认识(参考别人的) BF是对边进行操作,dijkstra 是对点进行操作,N个顶点的最短路最多是N-1条边,所以需要循环N-1次 1.初始化 2.迭代求解:反复对边集中的每条边进行松弛操作,使得顶点集v中的每个顶点vde最短距离逐步逼近其最短距离,运行v-1次 3:检验负权回路:判断边集中的每一条边的两个端点是否收敛,如果存在

ACM-最短路（SPFA,Dijkstra,Floyd）之最短路——hdu2544

***************************************转载请注明出处:http://blog.csdn.net/lttree*************************************** 最短路 Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 28761    Accepted Submissio

hdoj 2544 最短路 【最短路径模板题】

最短路 Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 33752    Accepted Submission(s): 14662 Problem Description 在每年的校赛里,所有进入决赛的同学都会获得一件很漂亮的t-shirt.但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候,却是非常累的!所以现在他们想要寻找

最短路算法 -- SPFA模板

一.算法步骤 建立一个队列,初始时队列里只有起始点,再建立一个数组记录起始点到所有点的最短路径(该数组的初始值要赋为极大值,该点到它本身的路径赋为0,下面的模板中该数组为dist[]).然后执行松弛操作,用队列里有的点作为起始点去刷新到所有点的最短路,如果刷新成功且被刷新点不在队列中则把该点加入到队列最后.重复执行直到队列为空. 二.算法模板 1 struct Edge 2 { 3 int s, e, dist; //边的起点.终点.长度 4 5 Edge() {} 6 Edge(int s,

KMP——模板 练手题

1. 洛谷  P3375 [模板]KMP字符串匹配 题目描述 如题,给出两个字符串s1和s2,其中s2为s1的子串,求出s2在s1中所有出现的位置. 为了减少骗分的情况,接下来还要输出子串的前缀数组next.如果你不知道这是什么意思也不要问,去百度搜[kmp算法]学习一下就知道了. 输入输出格式 输入格式: 第一行为一个字符串,即为s1(仅包含大写字母) 第二行为一个字符串,即为s2(仅包含大写字母) 输出格式: 若干行,每行包含一个整数,表示s2在s1中出现的位置 接下来1行,包括length

UVA 10801 Dij最短路（改模板）

题意:有n个电梯,目的地是第K层(起点是第0层),给出每个电梯的速度,以及每个电梯能到达的层数,如果中途需要换电梯的话,时间需要+60,求到达目的地的最短时间: 思路:Dij求最短路.如果是另一条路比较短的话,相当于乘别的电梯,也就是再+60,自己不可能和自己比,即d[e.v] 和 d[e.u] + d + 60比较即可: 1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include