hdu_2544 最短路

最新推荐文章于 2021-07-31 08:52:52 发布
最新推荐文章于 2021-07-31 08:52:52 发布
阅读量270 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/christry_stool/article/details/51465097
版权
图论 同时被 3 个专栏收录
21 篇文章 0 订阅
订阅专栏
---最短路
6 篇文章 0 订阅
订阅专栏
hdu
5 篇文章 0 订阅
订阅专栏

最短路

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

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

Source
UESTC 6th Programming Contest Online

Recommend
lcy

学习一下最短路吧，Bellman_ford做法 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <stack>
#include <bitset>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#define Si(a) scanf("%d",&a)
#define Sl(a) scanf("%lld",&a)
#define Sd(a) scanf("%lf",&a)
#define Ss(a) scanf("%s",a)
#define Pi(a) printf("%d\n",(a))
#define Pl(a) printf("%lld\n",(a))
#define Pd(a) printf("%lf\n",(a))
#define Ps(a) printf("%s\n",(a))
#define W(a) while(a--)
#define mem(a,b) memset(a,(b),sizeof(a))
#define FOP freopen("data.txt","r",stdin)
#define inf 0x3f3f3f3f
#define maxn 10010
#define mod 1000000007
#define PI acos(-1.0)
#define LL long long
using namespace std;

struct Edge
{
    int u,v;
    int cost;
}edge[maxn*2];

int dis[maxn*2],N,M;

int Bellman_Ford()
{
    int i,j;
    for(i=1;i<=N;i++)
    {
        if(i==1)dis[i]=0;
        else dis[i]=inf;
    }
    for(i=1;i<=N-1;i++)
    {
        for(j=1;j<=M*2;j++)
        {
            if(dis[edge[j].u]+edge[j].cost<dis[edge[j].v])
            {
                dis[edge[j].v]=dis[edge[j].u]+edge[j].cost;
            }
        }
    }
    for(j=1;j<=M*2;j++)
    {
        if(dis[edge[j].u]+edge[j].cost<dis[edge[j].v])
        {
            return 0;
        }
    }
    return 1;
}

int main()
{
    int i;
    while((scanf("%d%d",&N,&M))&&(N!=0||M!=0))
    {
        mem(edge,0);
        for(i=1;i<=M;i++)
        {
            Si(edge[i].u),Si(edge[i].v),Si(edge[i].cost);
            edge[i+M].v=edge[i].u;edge[i+M].u=edge[i].v;
            edge[i+M].cost=edge[i].cost;
        }
        if(Bellman_Ford())
        {
            Pi(dis[N]);
        }
    }
    return 0;
}

SPFA做法 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <stack>
#include <bitset>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#define Si(a) scanf("%d",&a)
#define Sl(a) scanf("%lld",&a)
#define Sd(a) scanf("%lf",&a)
#define Ss(a) scanf("%s",a)
#define Pi(a) printf("%d\n",(a))
#define Pl(a) printf("%lld\n",(a))
#define Pd(a) printf("%lf\n",(a))
#define Ps(a) printf("%s\n",(a))
#define W(a) while(a--)
#define mem(a,b) memset(a,(b),sizeof(a))
#define FOP freopen("data.txt","r",stdin)
#define inf 0x3f3f3f3f
#define maxn 110
#define mod 1000000007
#define PI acos(-1.0)
#define LL long long
using namespace std;

int edge[maxn][maxn];
int dis[maxn],N,M;
bool visit[maxn];
int SPFA()
{
    int i,j;
    for(i=1; i<=N; i++)
    {
        if(i==1)
        {
            dis[i]=0;
            visit[i]=true;
        }
        else
        {
            dis[i]=inf;
            visit[i]=false;
        }
    }
    queue<int> Q;
    Q.push(1);
    while(!Q.empty())
    {
        int temp=Q.front();
        Q.pop();
        for(i=1; i<=N; i++)
        {
            if(dis[temp]+edge[temp][i]<dis[i])
            {
                dis[i]=dis[temp]+edge[temp][i];
                if(!visit[i])
                {
                    Q.push(i);
                    visit[i]=true;
                }
            }
        }
        visit[temp]=false;
    }
}

int main()
{
    int i,j;
    while((scanf("%d%d",&N,&M))&&(N!=0||M!=0))
    {
        for(i=1; i<=N; i++)
        {
            for(j=1; j<=i; j++)
            {
                if(i==j)edge[i][j]=0;
                else edge[i][j]=edge[j][i]=inf;
            }
        }
        for(i=1; i<=M; i++)
        {
            int a,b,c;
            Si(a),Si(b),Si(c);
            edge[a][b]=c;
            edge[b][a]=c;
        }
        SPFA();
        Pi(dis[N]);
    }
    return 0;
}

Dijkstra做法 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <stack>
#include <bitset>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#define Si(a) scanf("%d",&a)
#define Sl(a) scanf("%lld",&a)
#define Sd(a) scanf("%lf",&a)
#define Ss(a) scanf("%s",a)
#define Pi(a) printf("%d\n",(a))
#define Pl(a) printf("%lld\n",(a))
#define Pd(a) printf("%lf\n",(a))
#define Ps(a) printf("%s\n",(a))
#define W(a) while(a--)
#define mem(a,b) memset(a,(b),sizeof(a))
#define FOP freopen("data.txt","r",stdin)
#define inf 0x3f3f3f3f
#define maxn 110
#define mod 1000000007
#define PI acos(-1.0)
#define LL long long
using namespace std;

int edge[maxn][maxn];
int dis[maxn],N,M;
bool visit[maxn];

int Dijkstra()
{
    int i,j;
    for(i=1; i<=N; i++)
    {
        if(i==1)dis[i]=0;
        else dis[i]=inf;

        visit[i]=false;
    }
    int u,v;
    while(1)
    {
        u=-1;
        for(v=1;v<=N;v++)
            if(!visit[v]&&(u==-1||dis[v]<dis[u]))
                u=v;
        if(u==-1)break;
        visit[u]=true;
        for(v=1;v<=N;v++)
        {
            dis[v]=min(dis[u]+edge[u][v],dis[v]);
        }
    }
}

int main()
{
    int i,j;
    while((scanf("%d%d",&N,&M))&&(N!=0||M!=0))
    {
        for(i=1; i<=N; i++)
        {
            for(j=1; j<=i; j++)
            {
                if(i==j)edge[i][j]=0;
                else edge[i][j]=edge[j][i]=inf;
            }
        }
        for(i=1; i<=M; i++)
        {
            int a,b,c;
            Si(a),Si(b),Si(c);
            edge[a][b]=c;
            edge[b][a]=c;
        }
        Dijkstra();
        Pi(dis[N]);
    }
    return 0;
}

floyd做法 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <stack>
#include <bitset>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#define Si(a) scanf("%d",&a)
#define Sl(a) scanf("%lld",&a)
#define Sd(a) scanf("%lf",&a)
#define Ss(a) scanf("%s",a)
#define Pi(a) printf("%d\n",(a))
#define Pl(a) printf("%lld\n",(a))
#define Pd(a) printf("%lf\n",(a))
#define Ps(a) printf("%s\n",(a))
#define W(a) while(a--)
#define mem(a,b) memset(a,(b),sizeof(a))
#define FOP freopen("data.txt","r",stdin)
#define inf 0x3f3f3f3f
#define maxn 110
#define mod 1000000007
#define PI acos(-1.0)
#define LL long long
using namespace std;

int edge[maxn][maxn];
int N,M;

int floyd()
{
    int i,j,k;
    for(k=1; k<=N; k++)
        for(i=1; i<=N; i++)
            for(j=1; j<=N; j++)
                edge[i][j]=min(edge[i][k]+edge[k][j],edge[i][j]);
}

int main()
{
    int i,j;
    while((scanf("%d%d",&N,&M))&&(N!=0||M!=0))
    {
        for(i=1; i<=N; i++)
        {
            for(j=1; j<=i; j++)
            {
                if(i==j)edge[i][j]=0;
                else edge[i][j]=edge[j][i]=inf;
            }
        }
        for(i=1; i<=M; i++)
        {
            int a,b,c;
            Si(a),Si(b),Si(c);
            edge[a][b]=c;
            edge[b][a]=c;
        }
        floyd();
        Pi(edge[1][N]);
    }
    return 0;
}

优先队列dijkstra 

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <stack>
#include <bitset>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#define Si(a) scanf("%d",&a)
#define Sl(a) scanf("%lld",&a)
#define Sd(a) scanf("%lf",&a)
#define Ss(a) scanf("%s",a)
#define Pi(a) printf("%d\n",(a))
#define Pl(a) printf("%lld\n",(a))
#define Pd(a) printf("%lf\n",(a))
#define Ps(a) printf("%s\n",(a))
#define W(a) while(a--)
#define mem(a,b) memset(a,(b),sizeof(a))
#define FOP freopen("data.txt","r",stdin)
#define inf 0x3f3f3f3f
#define maxn 110
#define mod 1000000007
#define PI acos(-1.0)
#define LL long long
using namespace std;

int dis[maxn],N,M;
bool visit[maxn];

struct node
{
    int x,d;
    node(int a,int b){x=a;d=b;}
    bool operator < (const node & a) const
    {
        if(d==a.d)return x<a.x;
        else return d>a.d;
    }
};

vector<node>edge[maxn];
int Dijkstra()
{
    int i,j;
    for(i=1; i<=N; i++)
    {
        if(i==1)dis[i]=0;
        else dis[i]=inf;

        visit[i]=false;
    }
    priority_queue<node> Q;
    Q.push(node(1,dis[1]));
    while(!Q.empty())
    {
        node x=Q.top();
        Q.pop();
        for(i=0;i<edge[x.x].size();i++)
        {
            node y=edge[x.x][i];
            if(x.d+y.d<dis[y.x])
            {
                dis[y.x]=x.d+y.d;
                Q.push(node(y.x,dis[y.x]));
            }
        }
    }

}

int main()
{
    int i,j;
    while((scanf("%d%d",&N,&M))&&(N!=0||M!=0))
    {
        for(i=1;i<=N;i++)edge[i].clear();
        for(i=1; i<=M; i++)
        {
            int a,b,c;
            Si(a),Si(b),Si(c);
            edge[a].push_back(node(b,c));
            edge[b].push_back(node(a,c));
        }
        Dijkstra();
        Pi(dis[N]);
    }
    return 0;
}





christry_stool
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU_2544 最短路
weixin_30719711的博客
09-23 66
HDU_2544 直接用队列优化的Bellman-Ford算法求到各个点的最短路即可。 #include<stdio.h>#include<string.h>int N,M,G[110][110],d[110];int q[110],inq[110];int init(){ int i,A,B,C; scanf("%d%d",&N,&am...
hdu_2544_最短路(spfa版子)
bin_gege的博客
07-15 284
题目连接：hdu_2544_最短路 存个自己写的SPFA的板子 #include #include #define mst(a,b) memset(a,b,sizeof(a)) #define F(i,a,b) for(int i=a;i<=b;i++) const int N=10011,inf=1<<30; int g[N],v[N*2],nxt[N*2],w[N*2],ed,d[N],
hdu_2544 最短路 (floyd算法)
徵羽調_xiao賤的专栏
08-17 633
原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=2544 分析：          求最短路，这里用floyd算法做，先入门一下。          关于floyd算法的中松弛的理解。          这样map[1][2]=Min(map[1][2],map[1][3]+map[3][2]); 我的代码： #includ
HDU - 2544 最短路
LOVE&AI的博客
02-27 146
最短路Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 77383    Accepted Submission(s): 33620Problem Description在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但...
HDU - 2544 最短路 (Floyd算法)
m0_58245389的博客
07-31 138
最短路 HDU - 2544 在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？ Input 输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，...
HDU-2544 最短路
Kiyonami Yu
08-29 387
#include <iostream> #include <cstdio> #include <cstring>using namespace std;const int INF = 999999999; int n, m; int graph[105][105]; int sign[105]; int root[105];void Dijkstra() { memset(sign, 0,
hdu2544 最短路 _最短路
wylu
05-02 211
  最短路   Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 63566    Accepted Submission(s): 27846     Problem Description 在每年的校赛里，所有进入决赛的同学...
HDU2544 最短路
点滴
03-12 237
HDU2544 最短路 题意： 求商店到操场的最短路径，无向图。 题解： 建图+dijkstra/ bellman_ford/ floyd/ spfa 因为这里的数据量很小，并且没有负环，所以四种算法都可以用。 dijkstar —— O(mlogn） 适合于没有负环的情况 bellman_Ford ——O(nm) ...
HDU 2544 最短路
qq_45589658的博客
08-08 186
题目连接：http://acm.hdu.edu.cn/showproblem.php?pid=2544 求工作人员从商店走到赛场的最短时间，也就是最短路问题。 最短路问题的常用算法为Floyd算法、Dijkstra算法。下面依次介绍两种方法并给出代码。 一、Floyd算法 Floyd算法，中文叫做弗洛伊德算法，是解决任意两点间的最短路径的一种算法。可以处理有向图或负权图（但不可存在负权回路）。这种算法的时间复杂度是O(N3)O(N^3)O(N3)，空间复杂度为O(N2)O(N^2)O(N2)。算法的原理与动
hdu_acm_1084.rar_ACM_HDU10_acm10_hdu_hdu 1084
09-23
【标题】"hdu_acm_1084.rar_ACM_HDU10_acm10_hdu_hdu 1084" 提供的是一个关于杭电（HDU）ACM竞赛第1084题的解决方案。该题目可能是在编程竞赛中常见的算法问题，而ACM（国际大学生程序设计竞赛）是全球知名的编程...
hdu_ACM.rar_ACM_hdu_hdu acm_hdu_ACM_杭电ACM
09-24
杭电hdu acm资料所用杭电的acm题
HDU_2010.rar_hdu 2010_hdu 20_hdu acm20
09-14
【标题】"HDU_2010.rar"是一个压缩包文件，其中包含了与"HDU 2010"相关的资源，特别是针对"HDU ACM20"比赛的编程题目。"hdu 2010"和"hdu 20"可能是该比赛的不同简称或分类，而"hdu acm20"可能指的是该赛事的第20届...
Rightmost Digit_hdu_
10-03
【标题】"Rightmost Digit HDU" 这道题目来源于HDU（杭州电子科技大学）的在线判题系统，通常这类题目是编程竞赛或者算法训练的一部分。"Rightmost Digit"直译为“最右边的数字”，我们可以推测这是一个关于数字...
最短路（HDU-2544）.rar
09-16
《最短路问题详解》 在计算机科学领域，最短路问题是一个经典的图论问题，其目标是寻找网络中两点间路径的最小成本。这个问题在众多应用中都有所体现，如交通规划、通信网络设计、社交网络分析等。在本篇内容中，...
基于Android校园淘书APP设计与实现.docx
最新发布
08-14
基于Android校园淘书APP设计与实现.docx
ssm_085_mysql_书籍借阅系统_.zip
08-14
本系统的开发主要是针对于图书馆管理系统进行设计和研发的。从角色角度方面来看其主要角色主要有管理员和读者两大角色。 其中管理员的主要功能模块包括管理员系统用户管理、读者管理、图书类别管理、公告管理、书架管理、图书管理、续借图书管理、归还图书管理、借阅图书管理、图书统计；读者的主要功能模块包括个人资料管理、公告管理、续借图书管理、归还图书管理、借阅图书管理等。
Git简介与基本操作.7z
08-14
Git是一个开源的分布式版本控制系统，用于敏捷高效地处理任何或小或大的项目。Git的基本操作通常涉及环境配置、仓库创建、文件添加与提交等步骤。
基于 UraniumVM 的 arm/arm64 虚拟化调试器（uvmdbg），适用于 macOS/iOS/Android
08-14
适用于 macOS/iOS/Linux/Android 的 arm/arm64/x86/x64 汇编级调试器，如 OllyDbg 和 X64Dbg。基于 UraniumVM 的 arm/arm64 虚拟化调试器（uvmdbg），适用于 macOS/iOS/Android。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值