NEFU-最短路，acm暑期培训

已于 2023-09-22 15:39:18 修改
阅读量147 收藏
点赞数
分类专栏： acm集训 # 最短路 文章标签： 算法 图论 数据结构
于 2023-08-01 19:54:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Landing_on_Mars/article/details/131841641
版权

                               

目录

                               

                                 A - 最短路

Problem - 2544 (hdu.edu.cn)

朴素版Dijkstra算法

优化版Dijkstra

 Bellman_ford版

       H - Delay Constrained Maximum Capacity Path

Problem - 1839 (hdu.edu.cn)

二分+Dijkstra版

二分+spfa版

                                 A - 最短路

Problem - 2544 (hdu.edu.cn)

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

InputcopyOutputcopy
2 1
1 2 3
3 3
1 2 5
2 3 5
3 1 2
0 0
 
3
2

朴素版Dijkstra算法

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
using namespace std;
typedef long long LL;
const int N = 100 + 5;
int G[N][N], d[N], v[N];
int n, m;

void Dijkstra() {
	memset(d, 0x3f3f3f3f, sizeof(d));
	d[1] = 0;
	for (int i = 1; i <= n; i++) {
		int x = -1;
		for (int j = 1; j <= n; j++) {
			if (!v[j] && (x == -1 || d[x] > d[j])) {
				x = j;
			}
		}
		v[x] = 1;
		for (int j = 1; j <= n; j++) {
			if (!v[j]) {
				d[j] = min(d[j], d[x] + G[x][j]);
			}
		}
	}
}

int main() {
	while (cin >> n >> m) {
		if (n == 0 && m == 0)
			break;
		memset(G, 0x3f3f3f3f, sizeof(G));
		for (int i = 1; i <= n; i++)
			G[i][i] = 0;
		memset(v, 0, sizeof(v));
		for (int i = 1, a, b, t; i <= m; i++) {
			scanf("%d%d%d", &a, &b, &t);
			G[b][a] = G[a][b] = min(G[a][b], t);
		}
		Dijkstra();
		cout << d[n] << endl;
	}
	return 0;
}

优化版Dijkstra

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
using namespace std;
typedef long long LL;
const int N = 100 + 5;
int n, m;
typedef struct st {
	int e, w;
}st;
vector<st>G[N];
int d[N], v[N];

bool operator > (const st& a, const st& b) {
	return a.w > b.w;
}

void Dijkstra() {
	memset(d, 0x3f3f3f3f, sizeof(d));
	memset(v, 0, sizeof(v));
	d[1] = 0;
	priority_queue<st, vector<st>, greater<st>>q;
	q.push({ 1,0 });
	int t;
	while (!q.empty()) {
		t = q.top().e;
		q.pop();
		if (v[t])
			continue;
		v[t] = 1;
		for (int i = 0; i < G[t].size(); i++) {
			int j = G[t][i].e;
			if (d[j] > d[t] + G[t][i].w) {
				d[j] = d[t] + G[t][i].w;
				q.push({ j,d[j] });
			}
		}
	}
}

int main() {
	while (cin >> n >> m) {
		if (n == 0 && m == 0)
			break;
		for (int i = 1,a,b,t; i <= m; i++) {
			scanf("%d%d%d", &a, &b, &t);
			G[a].push_back({ b,t });
			G[b].push_back({ a,t });
		}
		Dijkstra();
		cout << d[n] << endl;
		for (int i = 1; i <= n; i++)
			G[i].clear();
	}
	return 0;
}

 Bellman_ford版

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
using namespace std;
typedef long long LL;
const int N = 100 + 5, M = 1e4 + 5;
int n, m;
struct edge {
	int u, e, w;
}edge[M];
int d[N], backup[N];

void Bellman_ford() {
	memset(d, 0x3f3f3f3f, sizeof(d));
	d[1] = 0;
	for (int i = 1; i <= m; i++) {
		memcpy(backup, d, sizeof(d));
		for (int j = 1,a,b,t; j <= m; j++) {
			a = edge[j].e, b = edge[j].u, t = edge[j].w;
			if (d[a] > backup[b] + t) {
				d[a] = backup[b] + t;
			}
			if (d[b] > backup[a] + t)
				d[b] = backup[a] + t;
		}
	}
}

int main() {
	while (cin >> n >> m) {
		if (n == 0 && m == 0)
			break;
		for (int i = 1; i <= m; i++) {
			scanf("%d%d%d", &edge[i].u, &edge[i].e, &edge[i].w);
		}

		Bellman_ford();
		cout << d[n] << endl;
	}
	return 0;
}

       H - Delay Constrained Maximum Capacity Path

Problem - 1839 (hdu.edu.cn)

Consider an undirected graph with N vertices, numbered from 1 to N, and M edges. The vertex numbered with 1 corresponds to a mine from where some precious minerals are extracted. The vertex numbered with N corresponds to a minerals processing factory. Each edge has an associated travel time (in time units) and capacity (in units of minerals). It has been decided that the minerals which are extracted from the mine will be delivered to the factory using a single path. This path should have the highest capacity possible, in order to be able to transport simultaneously as many units of minerals as possible. The capacity of a path is equal to the smallest capacity of any of its edges. However, the minerals are very sensitive and, once extracted from the mine, they will start decomposing after T time units, unless they reach the factory within this time interval. Therefore, the total travel time of the chosen path (the sum of the travel times of its edges) should be less or equal to T.

Input

The first line of input contains an integer number X, representing the number of test cases to follow. The first line of each test case contains 3 integer numbers, separated by blanks: N (2 <= N <= 10.000), M (1 <= M <= 50.000) and T (1 <= T <= 500.000). Each of the next M lines will contain four integer numbers each, separated by blanks: A, B, C and D, meaning that there is an edge between vertices A and B, having capacity C (1 <= C <= 2.000.000.000) and the travel time D (1 <= D <= 50.000). A and B are different integers between 1 and N. There will exist at most one edge between any two vertices.

Output

For each of the X test cases, in the order given in the input, print one line containing the highest capacity of a path from the mine to the factory, considering the travel time constraint. There will always exist at least one path between the mine and the factory obbeying the travel time constraint.

Sample

InputcopyOutputcopy
2 
2 1 10 
1 2 13 10
4 4 20 
1 2 1000 15 
2 4 999 6 
1 3 100 15 
3 4 99 4 
13 
99

分析与总结：

因为每条路径的容量取决于这条路径中所有边中的最小容量，所以我们可以以此枚举最小容量。
但是如果一个一个容量的枚举，那明显效率太低了。

通过分析，可以看出，如果最低容量越大，那么符合要求的路径就越少，所以，根据容量的大小，路径数量是单调的。

有了单调性，就可以利用二分法了。

只要把容量从大到小进行排序，然后二分之，很快便能算出答案。
 

 这里的二分我最开始没有想到。这里的二分很妙，二分与最短路结合，真的太妙了。

二分+Dijkstra版


#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>

using namespace std;
typedef long long LL;
const int N = 1e4 + 5, M=5e4 + 5;
LL n, m,T;
typedef struct st {
	LL e, c, w;
}st;
vector<st>G[N];
LL d[N], v[N];
LL cap[M];
typedef struct stt {
	LL e, w;
}stt;

bool cmp(const LL& a, const LL& b){
	return a < b;
}

bool operator > (const stt& a, const stt& b) {
	return a.w > b.w;
}

LL Dijkstra(LL in) {
	memset(d, 0x3f3f3f3f3f3f3f3f, sizeof(d));
	memset(v, 0, sizeof(v));
	d[1] = 0;
	priority_queue<stt, vector<stt>, greater<stt>>q;
	q.push({ 1,0 });
	LL t;
	while (!q.empty()) {
		t = q.top().e;
		q.pop();
		if (v[t])
			continue;
		v[t] = 1;
		for (int i = 0; i < G[t].size(); i++) {
			if (G[t][i].c < in)
				continue;
			int j = G[t][i].e;
			if (d[j] > d[t] + G[t][i].w) {
				d[j] = d[t] + G[t][i].w;
				q.push({ j,d[j] });
			}
		}
	}
	return d[n];
}

int main() {
	int X;
	cin >> X;
	while (X--) {
		cin >> n >> m >> T;
		for (int i = 0; i <= n; i++) {
			G[i].clear();
		}
		memset(cap, 0, sizeof(cap));
		for (int i = 1,a,b,c,t; i <= m; i++) {
			scanf("%d%d%d%d", &a, &b, &c, &t);
			G[a].push_back({ b,c,t });
			G[b].push_back({ a,c,t });
			cap[i] = c;
		}
		sort(cap + 1, cap + 1 + m, cmp);
		
		int l = 1, r = m, mid, ans;
		LL t;
		while (l <= r) {
			mid = l + (r - l) / 2;
			t = Dijkstra(cap[mid]);
			if (t==0x3f3f3f3f3f3f3f3f||t > T) {
				//这里是r = mid - 1，不是l = mid + 1千万别搞混了，我这里错了好几次
                r = mid - 1;
			}
			else {
				ans = mid;
				l = mid + 1;
			}
		}
		//cout << ans << endl;
		cout << cap[ans] << endl;
	}

	return 0;
}

二分+spfa版

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
using namespace std;
typedef long long LL;
const int N = 1e4 + 5,M=5e4+5;
int n, m, T;
int d[N], v[N], cap[M];
typedef struct st {
	int e, c, w;
}st;
vector<st>G[N];

int cmp(const int &a,const int&b) {
	return a < b;
}

int spfa(int in) {
	memset(d, 0x3f3f3f3f, sizeof(d));
	memset(v, 0, sizeof(v));
	d[1] = 0;
	v[1] = 1;
	queue < int>q;
	q.push(1);
	int t;
	while (!q.empty()) {
		t = q.front();
		q.pop();
		v[t] = 0;
		for (int i = 0,j,dist; i < G[t].size(); i++) {
			if (G[t][i].c >= in) {
				j = G[t][i].e;
				dist = G[t][i].w;
				if (d[j] > d[t] + dist) {
					d[j] = d[t] + dist;
					if (v[j] == 0) {
						v[j] = 1;
						q.push(j);
					}
				}
			}
		}
	}
	return d[n];
}

int main() {
	int X;
	cin >> X;
	while (X--) {
		cin >> n >> m >> T;
		for (int i = 0; i <= n; i++) {
			G[i].clear();
		}
		for (int i = 1,a,b,c,w; i <= m; i++) {
			scanf("%d%d%d%d", &a, &b, &c, &w);
			G[a].push_back({ b,c,w });
			G[b].push_back({ a,c,w });
			cap[i] = c;
		}

		sort(cap + 1, cap + 1 + m, cmp);

		int l = 1, r = m, mid, ans,t;
		while (l <= r) {
			mid = l + (r - l) / 2;
			t = spfa(cap[mid]);
			if ( t > T) {
				r = mid - 1;
			}
			else {
				ans = mid;
				l = mid + 1;
			}
		}
		cout << cap[ans] << endl;
	}
	return 0;
}

Landing_on_Mars
关注
专栏目录
nefu-数据库实验-数据查询和视图操作
God_linlin的博客
11-21 484
数据库实验二
2022-nefu-数据结构课设完整版本
09-27
在这个“2022-nefu-数据结构课设完整版本”中，我们可以看到一个针对东北林业大学（NEFU）学生的数据结构课程设计项目。这个项目的完整版本包括了源码，这意味着我们可以深入学习和理解每个数据结构的实现细节。 ...
图论--最短路问题--Bellman-Ford算法
Sunflower的博客
08-11 1391
#include #include #include #include using namespace std; int n,m,s;//n可以想为银行拥有的货币种类，m为银行中可以提供货币交换的数量，s为这个人拥有的货币种类 double v,dis[101];//v为这个人拥有的货币的总量；储存每种货币的总数（本来有的和每次兑换） struct point {     int
NEFU-2023-JAVA实验八
qq_62377885的博客
05-17 718
理解基于IO流文件操作的过程及意义理解并掌握基于字节数组缓冲区，实现IO操作方法理解并掌握基于NIO文件目录的创建方法理解并掌握基于NIO文件创建的创建方法理解并掌握基于NIO文件的删除方法实验内容（1）按要求实现IOTest类中的方法，提交IOTest类；（2）提交测试代码的运行截图；（3）说明实验中出现的问题和解决过程，写出实验的心得体会。
NEFU-2023-Java实验二
qq_62377885的博客
03-18 1251
大底包含了JAVA硬性规定的作业代码，并非最优解，仅供参考并会持续更新。勿要无脑copy，对自己负责。如果代码有误或者优化建议，直接相应博客下方评论或者qq找我如果对代码有理解不了的或者疑惑可以询问我，但是请确保你已经自己思考过或者查过搜索引擎（如果我原模原样搜到了资料的话我会锤你的hh）。一些语法和库的资料查询网站受个人风格影响，部分题目解题方式可能没按照教学要求，如有必要请自己按教学要求做一遍。如果可以的话，麻烦借鉴完以后给我博客来个三连啥的，这可能对我以后找工作或者其他博客的推广什么的有些帮助，感谢
NEFU-ACM 寒假大一考试题解（2020.2.22）
nefu_ljw的博客
02-23 1226
这是给大一acm训练出的考试题题解。 题目名字有“jwGG”的3道题，是我出的（jwGG的签到题、jwGG与yzMM的字符串、jwGG与bwMM的字符串）， 其他的题是实验室各位大佬出的。 感谢所有出题人的付出。 nefu 2133 jwMM的疯狂A-B 签到题。两个set，直接模拟。 #include <bits/stdc++.h> using namespace std; set<int>s1,s2; int n,m,x,flag=0; int main() { ios::sync_with
NEFU-2023-Java实验一
qq_62377885的博客
03-11 771
大底包含了JAVA硬性规定的作业代码，并非最优解，仅供参考并会持续更新。勿要无脑copy，对自己负责。如果代码有误或者优化建议，直接相应博客下方评论或者qq找我如果对代码有理解不了的或者疑惑可以询问我，但是请确保你已经自己思考过或者查过搜索引擎（如果我原模原样搜到了资料的话我会锤你的hh）。一些语法和库的资料查询网站受个人风格影响，部分题目解题方式可能没按照教学要求，如有必要请自己按教学要求做一遍。如果可以的话，麻烦借鉴完以后给我博客来个三连啥的，这可能对我以后找工作或者其他博客的推广什么的有些帮助，感谢
nefu-1297 表哥的旅行（最短路问题）
weixin_30788619的博客
09-09 73
题目链接： http://acm.nefu.edu.cn/JudgeOnline/problemShow.php?problem_id=1197 注意事项： 1.初始数组长度为零 2.同样路径可能花费不同的时间 3.运用变形的Dijkstra算法 代码思路： 先初始化二维数组e和cot再输入数据并更新二维数组e和最大的cot，接着输入能到达的点fly并把e[fly][0]和e[0][...
NEFU-JAVA锐格实验
weixin_62671257的博客
04-16 769
输入一个正整数repeat (0
NEFU-数据结构 实验2-栈和队列
2301_80330802的博客
12-14 367
NEFU-数据结构 实验2-栈和队列
nefu-开源
05-15
"nefu-开源"是一个专为网络服务监控设计的实用工具，名为Network Fidelity Utility。这个项目遵循开源软件的理念，允许用户查看、分析并管理网络的稳定性和性能。开源软件的核心价值在于其开放源代码，这意味着任何...
NEFU-计算机网络实验4
11-25
【实验名称】基于Wireshark的网络协议分析 【实验目的】 1. **掌握Wireshark的基本使用**：包括启动Wireshark，设置捕获接口，开始和停止数据捕获，以及如何查看和分析捕获的数据包。 2. **熟悉Wireshark过滤规则...
nefu-Web：WEB课程设计-----软件工程专业网站
02-02
nefu-Web 一个WEB课设 功能 主要板块内容：专业介绍，新闻，公告，实验室，教师队伍，优秀毕业生等 管理员登录后，可在后台对新闻公告信息进行增删改改查 过滤器，非管理员无法使用管理功能 主页列出最近4个新闻与...
NEFU-java实验报告.rar
06-15
【NEFU-java实验报告】这份压缩包文件显然与东北林业大学（NEFU）的Java编程课程相关，可能是学生完成的一项实验或项目的报告。Java是一种广泛使用的面向对象的编程语言，以其跨平台、安全性高和可移植性强等特点而...
力扣 困难 154.寻找旋转排序数组中的最小值 II
qq_51352130的博客
09-23 373
153.寻找旋转排序数组中的最小值在此基础上，进行二分之前，单独处理一下左指针和最后一个数相同的情况就好了。left++;} else {
二叉树最小深度
最新发布
2301_80161204的博客
09-27 218
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 805
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
atcoder abc372 启发式合并， dp
2201_75845839的博客
09-22 505
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
ACM程序设计入门：算法原理与竞赛解析
这份资料详细介绍了ACM竞赛的背景、目的以及在中国的发展历程，同时也包含了东北林业大学（NEFU）参与ACM竞赛的历史和未来规划。 开课目的主要有以下几个方面： 1. 为大学ACM代表队培养有潜力的选手。 2. 提升学生...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值