洛谷 P3371 【模板】单源最短路径（弱化版） Floyd算法 邻接矩阵/Dijkstra算法 邻接表 堆优化/Bellman-Ford算法/Bellman-Ford算法优化/SPFA算法

最新推荐文章于 2022-07-17 17:09:06 发布
最新推荐文章于 2022-07-17 17:09:06 发布
阅读量481 收藏 2
点赞数
分类专栏： 跟着大佬学算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mrcrack/article/details/103324269
版权

洛谷   P3371 【模板】单源最短路径（弱化版）   Floyd算法 邻接矩阵/Dijkstra算法 邻接表  堆优化/Bellman-Ford算法/Bellman-Ford算法优化/SPFA算法

//在线测评地址https://www.luogu.com.cn/problem/P3371

方法一：Floyd算法

 样例数据Floyd算法执行过程如下

//P3371 【模板】单源最短路径（弱化版）
//https://www.luogu.com.cn/problem/P3371
//在线测评地址https://www.luogu.com.cn/problem/P3371
//2147483647考虑采用long long
//floyd算法
//10^8*4/1024/1024=400MB数组开到10^6
//样例通过，提交，测试点2,9,10RE,1,3-8WA不敢相信。2019-11-30 13:57
/*
翻看讨论记录，
5 15 5
2 2 270
1 4 89
2 1 3
5 5 261
5 2 163
5 5 275
4 5 108
4 4 231
3 4 213
3 3 119
3 1 77
3 1 6
2 4 83
5 5 196
5 5 94
这么多从起点到终点一样的路是想干啥！！！！！
而且，从那条路能到3号点！！！！！

该题数据真毒瘤啊。看到了数据，该怎么干，那就没问题了。
两点之间有多条路径，那么选最短的。
*/
//if(a[u][v]>w)a[u][v]=w;//两点间有多条路径，选最短的。不看数据，这点根本想不到。
//提交70分，测试点1,3-8AC,2,9,10WA.还算满意。2019-11-30 14:22

#include <stdio.h>
#define LL long long
#define maxn 1010
#define INF 2147483647
LL a[maxn][maxn];
int n,m,s;
int main(){
	int k,i,j,u,v;
	LL w;
	scanf("%d%d%d",&n,&m,&s);
	for(i=1;i<=n;i++)
		for(j=1;j<=n;j++)
			if(i==j)a[i][j]=0;
			else a[i][j]=INF;
	for(i=1;i<=m;i++){
		scanf("%d%d%lld",&u,&v,&w);
		if(a[u][v]>w)a[u][v]=w;//两点间有多条路径，选最短的。不看数据，这点根本想不到。
	}
	for(k=1;k<=n;k++)
		for(i=1;i<=n;i++)
			for(j=1;j<=n;j++)
				if(a[i][j]>a[i][k]+a[k][j])
					a[i][j]=a[i][k]+a[k][j];
	printf("%lld",a[s][1]);
	for(i=2;i<=n;i++)printf(" %lld",a[s][i]);
	printf("\n");
	return 0;
}

方法二：Dijkstra算法+邻接矩阵

 

//Dijkstra+邻接矩阵
//样例通过，提交70分。2019-12-1 10:49
#include <stdio.h>
#include <string.h>
#define INF 2147483647
#define LL long long
#define maxn 1010
int n,m,s,vis[maxn];
LL a[maxn][maxn],d[maxn];
void init(){
	int i,j,u,v;
	LL w;
	scanf("%d%d%d",&n,&m,&s);
	for(i=1;i<=n;i++)
		for(j=1;j<=n;j++)
			if(i==j)a[i][j]=0;
			else a[i][j]=INF;
	for(i=1;i<=m;i++){
		scanf("%d%d%lld",&u,&v,&w);
		if(a[u][v]>w)a[u][v]=w;//取最短
	}
}
int findMin(){
	int i,k,mn=INF;
	for(i=1;i<=n;i++)
		if(!vis[i]&&mn>=d[i])
			mn=d[i],k=i;
	return k;
}
void Dijkstra(int s){
	int i,j,k;
	memset(vis,0,sizeof(vis));
	for(i=1;i<=n;i++)d[i]=INF;
	d[s]=0;
	for(j=1;j<=n;j++){//循环次数
		k=findMin(),vis[k]=1;
		for(i=1;i<=n;i++){
			if(!vis[i]&&d[i]>d[k]+a[k][i])
				d[i]=d[k]+a[k][i];
		}
	}
	printf("%lld",d[1]);
	for(i=2;i<=n;i++)printf(" %lld",d[i]);
	printf("\n");
}
int main(){
	init();
	Dijkstra(s);
	return 0;
}

方法三：Dijkstra算法+邻接表

//Dijkstra+邻接表
//样例通过，提交AC。2019-12-1 14:46真是没想到，能AC.

#include <stdio.h>
#include <string.h>
#define INF 2147483647
#define LL long long
#define maxn 10010
int n,m,s,vis[maxn],head[maxn],cnt=0;
LL d[maxn];
struct node{
	int to,next,w;
}e[500100];
void add_edge(int u,int v,LL w){//邻接表   不怕遇到重边
	cnt++,e[cnt].to=v,e[cnt].w=w,e[cnt].next=head[u],head[u]=cnt;
}
void init(){
	int i,j,u,v;
	LL w;
	memset(head,0,sizeof(head));
	scanf("%d%d%d",&n,&m,&s);
	for(i=1;i<=m;i++){
		scanf("%d%d%lld",&u,&v,&w);
		add_edge(u,v,w);
	}
}
int findMin(){
	int i,k,mn=INF;
	for(i=1;i<=n;i++)
		if(!vis[i]&&mn>=d[i])
			mn=d[i],k=i;
	return k;
}
void Dijkstra(int s){
	int i,j,k,b,u,v;
	memset(vis,0,sizeof(vis));
	for(i=1;i<=n;i++)d[i]=INF;
	d[s]=0;
	for(j=1;j<=n;j++){//循环次数
		k=findMin(),vis[k]=1;
		for(b=head[k];b;b=e[b].next){
			v=e[b].to;
			if(!vis[v]&&d[v]>d[k]+e[b].w)
				d[v]=d[k]+e[b].w;
		}
	}
	printf("%lld",d[1]);
	for(i=2;i<=n;i++)printf(" %lld",d[i]);
	printf("\n");
}
int main(){
	init();
	Dijkstra(s);
	return 0;
}

方法四：Dijkstra算法+邻接表+堆优化

//Dijkstra+邻接表+堆优化
//此文https://www.cnblogs.com/-Wind-/p/10164910.html代码写得不错，值得学习
//样例通过，提交AC。2019-12-1 21:34

#include <cstdio>
#include <cstring>
#include <queue>
#define INF 2147483647
#define LL long long
#define maxn 10010
using namespace std;
int n,m,s,vis[maxn],head[maxn],cnt=0;
LL d[maxn];
struct node{
	int w,u;//此处错写成int u,w;
	bool operator <(const node &a)const{//请注意此处格式的写法，缺一不可
		return a.w<w;
	}
};
struct node1{
	int to,next,w;
}e[500100];
priority_queue<node> q;
void add_edge(int u,int v,LL w){//邻接表   不怕遇到重边
	cnt++,e[cnt].to=v,e[cnt].w=w,e[cnt].next=head[u],head[u]=cnt;
}
void init(){
	int i,j,u,v;
	LL w;
	memset(head,0,sizeof(head));
	scanf("%d%d%d",&n,&m,&s);
	for(i=1;i<=m;i++){
		scanf("%d%d%lld",&u,&v,&w);
		add_edge(u,v,w);
	}
}
void Dijkstra(int s){
	int i,b,u,v;
	memset(vis,0,sizeof(vis));
	for(i=1;i<=n;i++)d[i]=INF;
	d[s]=0;
	q.push((node){0,s});
	while(!q.empty()){
		u=q.top().u;
		q.pop();
		if(vis[u])continue;
		vis[u]=1;
		for(b=head[u];b;b=e[b].next){
			v=e[b].to;
			if(!vis[v]&&d[v]>d[u]+e[b].w){//此处错写成if(!vis[v]&&d[v]>d[k]+e[b].w){
				d[v]=d[u]+e[b].w;//此处错写成d[v]=d[k]+e[b].w;
				q.push((node){d[v],v});
			}
		}
	}
	printf("%lld",d[1]);
	for(i=2;i<=n;i++)printf(" %lld",d[i]);
	printf("\n");
}
int main(){
	init();
	Dijkstra(s);
	return 0;
}

方法五：Bellman-Ford算法

样例通过，提交AC.2019-12-13

#include <stdio.h>
#define maxm 500010
#define INF 2147483647
#define LL long long
struct node{
	int u,v,w;
}e[maxm];
LL d[10010];
int n,m,s;
int main(){
	int i,j;
	scanf("%d%d%d",&n,&m,&s);
	for(i=1;i<=m;i++)scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
	for(i=1;i<=n;i++)d[i]=INF;
	d[s]=0;
	for(i=1;i<=n-1;i++)
		for(j=1;j<=m;j++)
			if(d[e[j].v]>d[e[j].u]+e[j].w)d[e[j].v]=d[e[j].u]+e[j].w;//以边为中转。
	printf("%lld",d[1]);
	for(i=2;i<=n;i++)printf(" %lld",d[i]);
	printf("\n");
	return 0;
}

方法六：Bellman-Ford算法优化

//Bellman-Ford优化
//样例通过，提交AC.2019-12-13

 

#include <stdio.h>
#define maxm 500010
#define INF 2147483647
#define LL long long
struct node{
	int u,v,w;
}e[maxm];//边 
LL d[10010];
int n,m,s;
int main(){
	int i,j,check;
	scanf("%d%d%d",&n,&m,&s);
	for(i=1;i<=m;i++)scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
	for(i=1;i<=n;i++)d[i]=INF;
	d[s]=0;
	for(i=1;i<=n-1;i++){
		check=0;
		for(j=1;j<=m;j++)
			if(d[e[j].v]>d[e[j].u]+e[j].w){
				d[e[j].v]=d[e[j].u]+e[j].w;//以边为中转。
				check=1;
			}	
		if(check==0)break;		
	}
	printf("%lld",d[1]);
	for(i=2;i<=n;i++)printf(" %lld",d[i]);
	printf("\n");
	return 0;
}

方法七：SPFA算法

//样例通过，提交AC.2019-12-2

#include <stdio.h>
#include <string.h>
#define INF 2147483647
#define LL long long
#define maxn 10010
int n,m,s,vis[maxn],head[maxn],cnt=0,q[maxn*10],h,t;
LL d[maxn];
struct node{
	int to,next,w;
}e[500100];
void add_edge(int u,int v,LL w){//邻接表   不怕遇到重边
	cnt++,e[cnt].to=v,e[cnt].w=w,e[cnt].next=head[u],head[u]=cnt;
}
void init(){
	int i,j,u,v;
	LL w;
	memset(head,0,sizeof(head));
	scanf("%d%d%d",&n,&m,&s);
	for(i=1;i<=m;i++){
		scanf("%d%d%lld",&u,&v,&w);
		add_edge(u,v,w);
	}
}
void SPFA(int s){
	int i,j,k,b,u,v;
	memset(vis,0,sizeof(vis));
	for(i=1;i<=n;i++)d[i]=INF;
	d[s]=0,h=t=1,q[t]=s,t++;
	while(h<t){
		u=q[h];
		for(b=head[u];b;b=e[b].next){
			v=e[b].to;
			if(d[v]>d[u]+e[b].w){
				d[v]=d[u]+e[b].w;
				if(!vis[v])q[t]=v,t++,vis[v]=1;
			}
		}
		vis[u]=0,h++;
	}
	printf("%lld",d[1]);
	for(i=2;i<=n;i++)printf(" %lld",d[i]);
	printf("\n");
}
int main(){
	init();
	SPFA(s);
	return 0;
}

 

mrcrack
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
题解-【模板】单源最短路径（弱化版）
Ampty36的博客
04-19 219
题目背景 本题测试数据为随机数据，在考试中可能会出现构造数据让SPFA不通过，如有需要请移步 P4779。 题目描述 如题，给出一个有向图，请输出从某一点出发到所有点的最短路径长度。 输入输出格式 输入格式： 第一行包含三个整数N、M、S，分别表示点的个数、有向边的个数、出发点的编号。 接下来M行每行包含三个整数Fi、Gi、Wi，分别表示第i条有向边的出发点、目标点和长度。 输出格式： 一行，包含...
洛谷 P3371 【模板】单源最短路径（弱化版）spfa算法 最短路
aiwo1376301646的博客
07-09 261
题目链接： https://www.luogu.org/problemnew/show/P3371 思路： 1：本题数据比较水 2：spfa算法 #include<bits/stdc++.h> using namespace std; const int maxn=10001; vector<pair<int,int> >e[maxn]; int ...
【模板】单源最短路径（弱化版）
StilllFantasy的博客
10-28 305
其实也就是SPFA模板代码了 题目不多描述 洛谷P3371 直接贴出AC代码 #include&lt;iostream&gt; #include&lt;vector&gt; #include&lt;queue&gt; using namespace std; int h,t; int dis[10001]; struct edge { int to,w; }; int n,m; int vis[...
P3371 【模板】单源最短路径（弱化版）
You_are_hanson的博客
07-17 327
P3371 【模板】单源最短路径（弱化版） 主要知识点：迪杰斯特拉和链式前向星
洛谷 P3371 【模板】单源最短路径（弱化版）
追殇 | Blog
04-19 339
**测评地址：**https://www.luogu.org/problemnew/show/P3371 一、dijkstra 测评结果：https://www.luogu.org/recordnew/show/18342452 #include<iostream> #include<cstdio> #include<cstring> using namespa...
图算法-最小生成树和单源顶点最短路径
03-21
2. **贝尔曼-福特算法（Bellman-Ford Algorithm）**：对图进行V-1次松弛操作（V为顶点数），每次尝试缩短路径长度。它可以处理负权边，而迪杰斯特拉算法则不适用于这种情况。 3. **弗洛伊德-沃拉斯算法（Floyd-...
Dijkstra算法找最短路径代码_dijkstra_Dijkstra算法找最短路径代码_dijkstra算法_
10-03
Dijkstra算法，由荷兰计算机科学家艾兹格·迪科斯彻于1956年提出，是一种用于在图中寻找单源最短路径的算法。它适用于加权有向图或无向图，且所有边的权重都是非负的。这个算法的核心思想是通过逐步扩展最短路径树来...
最短路径算法Dijkstra源代码
06-22
此时，可以使用Bellman-Ford算法或Floyd-Warshall算法来求解。 - 对于带权重的图，可以使用二叉优先队列（二叉堆）进行优化，以提高查找和插入的速度。 `Dijkstra_test`文件可能是Dijkstra算法的测试用例，它可能...
基于matlab dijkstra算法，可以求解图论中的两点间最短路径.rar
最新发布
04-19
在实际应用中，我们可能还需要考虑边的容量、负权值等问题，这时可能需要采用其他算法，如Bellman-Ford或Floyd-Warshall。 五、结论 Dijkstra算法是解决图论中单源最短路径问题的重要工具，其MATLAB实现简单高效。...
最短路径算法_算法_最短路径_
10-03
在实现这些算法时，需要考虑数据结构的选择，如邻接矩阵或邻接表，以及如何有效地存储和更新路径信息。同时，优化技巧如使用堆或二叉堆作为优先队列，可以提高算法的执行速度。 在分析最短路径问题时，还需要考虑...
洛谷 P3371 【模板】单源最短路径
liangzihao1的博客
02-11 797
题目描述如题，给出一个有向图，请输出从某一点出发到所有点的最短路径长度。输入输出格式输入格式： 第一行包含三个整数N、M、S，分别表示点的个数、有向边的个数、出发点的编号。接下来M行每行包含三个整数Fi、Gi、Wi，分别表示第i条有向边的出发点、目标点和长度。输出格式： 一行，包含N个用空格分隔的整数，其中第i个整数表示从点S出发到点i的最短路径长度（若S=i则最短路径长度为0，若从点S无法到达
洛谷 P1294 高手去散步-邻接矩阵+dfs-求无向图的一条最长路径
m0_51955470的博客
04-13 475
输入: 4 6 1 2 10 2 3 20 3 4 30 4 1 40 1 3 50 2 4 60 输出: 150 代码如下: #include <iostream> using namespace std; int ans = -1; const int N = 25; int mp[N][N]; bool vis[N]; int n, m; void dfs(int u, int sum) { ans = max(ans, sum); for (int i = 1; i <
P3371 单源最短路径 Bellman-Ford算法
qq_14886903的博客
08-01 223
看到还没人用Bellman-Ford过，赶紧水一发 lz非常弱，求各位大佬轻喷qwq 洛谷题目传送门：P3371 0.“松弛”操作 如果存在一条边(u,v)(u,v)(u,v)通过中继的方式可以让起点到vvv的距离缩短，那么就通过中继点缩短这个距离。 举个栗子： (用数组dis[]dis[]dis[]来表示起点到每个点的距离，以下同样) 一开始，dis[2]=1000dis[2]=1000dis[2]=1000，dis[3]=2dis[3]=2dis[3]=2（默认起点为1,以下同样） 通过3中继明显比从
LG-图最短路径-P-3371
HALF愚笨角
02-01 124
【模板】单源最短路径（弱化版）题目相关题解相关别人的！邻接表+spfa代码邻接表+spfa 题目相关 给出一个有向图，请输出从某一点出发到所有点的最短路径长度。 输入格式 第一行包含三个整数 n,m,s, 分别表示点的个数、有向边的个数、出发点的编号。 接下来 m 行每行包含三个整数 u,v,w 表示一条u→v 的，长度为 w 的边。 输出格式 输出一行 n 个整数，第 i 个表示 s 到第 i个点的最短路径，若不能到达则输出 2^31−1。 输入输出样例 输入 4 6 1 1 2 2 2 3 2 2 4
洛谷P1144 最短路计数bellman bfs
hahahaki的博客
05-30 251
题目描述 给出一个NN个顶点MM条边的无向无权图，顶点编号为1-N1−N。问从顶点11开始，到其他每个点的最短路有几条。 输入格式 第一行包含22个正整数N,MN,M，为图的顶点数与边数。 接下来MM行，每行22个正整数x,yx,y，表示有一条顶点xx连向顶点yy的边，请注意可能有自环与重边。 输出格式 共NN行，每行一个非负整数，第ii行输出从顶点11到顶点ii有多少条不同的最短路，由于答案有可能会很大，你只需要输出ans \bmod 100003ansmod100003后的结果即可。如果无法到达顶点ii
洛谷P1339 热浪（Bellman-ford）
weixin_51562198的博客
11-28 196
代码总览 #include <bits/stdc++.h> using namespace std; const int I=0x3f3f3f; const int N=7000; int n,m,s,t; int u[N],v[N],w[N],dis[N]; int i,j; int main(){ cin>>n>>m>>s>>t; //n个点，m条边，s是起点，t是终点 for(i=1;i<=m;i++)
【图论】C006_洛谷模板题：负环（SPFA / Bellman-Ford / 链式向前星）
无敌兔0x01
04-13 310
一、题目描述 寻找一个从顶点 1 所能到达的负环，负环定义为：一个边权之和为负的环。 输入格式 本题有多组数据 第一行一个正整数 TT 表示数据组数，对于每组数据： 第一行两个正整数 N,M，表示图有 N 个顶点，M 条边 接下来 MM 行，每行三个整数 a, b, wa,b,w，表示a \rightarrow ba→b 有一条权值为 ww 的边（若 w<0w<0 则为单向，否则双...
Floyd算法求单源最短路（图，数据结构）
Acmer_future_victor的博客
12-13 694
什么是单源最短路？ 给定一个图和图中的一个点，求该点到其余各点的最短距离。 Floyd算法思路：计算某点到其余各点的距离，可先求该点到其中一个点的距离，其他各点类似。假设求i点到j点的距离，跳点为空时，最短距离就是i到j的最短距离，跳点为1时，最短距离为D[i][j] = min{D[i][j],D[i][1]+D[1][j]},跳点为1和2时,最短距离为D[i][j]=min{D[i][j],D
图算法 单源最短路径 Dijkstra算法（邻接表/邻接矩阵+优先队列STL)
06-06
Dijkstra算法是解决单源最短路径问题的一种经典算法，其基本思想是利用贪心的思想，每次选取未确定最短路径的节点中距离起点最近的节点，然后根据该节点更新与该节点相邻的节点的距离。具体实现可以采用邻接表或邻接...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值