1111 Online Map (30分)

最新推荐文章于 2021-12-13 09:31:25 发布
最新推荐文章于 2021-12-13 09:31:25 发布
阅读量157 收藏
点赞数
分类专栏： PAT # Dijkstra # 深度优先搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43116322/article/details/104115379
版权
PAT 同时被 3 个专栏收录
80 篇文章 1 订阅
订阅专栏
深度优先搜索
12 篇文章 0 订阅
订阅专栏
Dijkstra
6 篇文章 0 订阅
订阅专栏

在这里插入图片描述
在这里插入图片描述
可以直接Dijkstra，也可以先用Dijkstra求出所有最短路，再用DFS选出最佳的一条。
直接用Dijkstra解决，需要设置额外的数组：

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
int intersectNum, streetNum;
int source, destination;
const int inf = 0x7fffffff;
struct node {
	int time, length;
	node() {
		time = inf;
		length = inf;
	}
}map[520][520];
bool visited[520] = { false };
int minimumDistance[520];
int minimumTime[520];
int previous[520];	//各结点的前驱结点
int intersection[520] = { 0 };
vector<int> getPath(int cur) {
	vector<int> path;
	while (cur != -1) {
		path.push_back(cur);
		cur = previous[cur];
	}
	return path;
}
int main() {
	scanf("%d %d", &intersectNum, &streetNum);
	for (int i = 0;i < streetNum;i++) {
		int v1, v2, oneway, length, time;
		scanf("%d %d %d %d %d", &v1, &v2, &oneway, &length, &time);
		map[v1][v2].length = length;
		map[v1][v2].time = time;
		if (oneway == 0) {
			map[v2][v1].length = length;
			map[v2][v1].time = time;
		}
	}
	scanf("%d %d", &source, &destination);

	//Dijkstra找距离最短路
	fill(minimumDistance, minimumDistance + 520, inf);
	fill(minimumTime, minimumTime + 520, inf);
	fill(visited, visited + 520, false);
	fill(previous, previous + 520, -1);
	minimumDistance[source] = 0;
	minimumTime[source] = 0;
	for (int i = 0;i < intersectNum;i++) {
		int u = -1, minDis = inf;
		for (int j = 0;j < intersectNum;j++) {
			if (!visited[j] && minimumDistance[j] < minDis) {
				u = j;
				minDis = minimumDistance[j];
			}
		}
		if (u == -1)
			break;
		visited[u] = true;
		for (int v = 0;v < intersectNum;v++) {
			if (!visited[v] && map[u][v].length != inf) {
				if (map[u][v].length + minimumDistance[u] < minimumDistance[v] ||
					map[u][v].length + minimumDistance[u] == minimumDistance[v] && map[u][v].time + minimumTime[u] < minimumTime[v]) {
					previous[v] = u;
					minimumDistance[v] = map[u][v].length + minimumDistance[u];
					minimumTime[v] = map[u][v].time + minimumTime[u];
				}
			}
		}
	}
	vector<int> shortestDisPath = getPath(destination);
	int minDistance = minimumDistance[destination];

	//Dijkstra找时间最短路
	fill(minimumDistance, minimumDistance + 520, inf);
	fill(minimumTime, minimumTime + 520, inf);
	fill(visited, visited + 520, false);
	fill(previous, previous + 520, -1);
	fill(intersection, intersection + 520, inf);
	minimumTime[source] = 0;
	minimumDistance[source] = 0;
	intersection[source] = 0;
	for (int i = 0;i < intersectNum;i++) {
		int u = -1, minT = inf;
		for (int j = 0;j < intersectNum;j++) {
			if (!visited[j] && minimumTime[j] < minT) {
				u = j;
				minT = minimumTime[j];
			}
		}
		if (u == -1)
			break;
		visited[u] = true;
		for (int v = 0;v < intersectNum;v++) {
			if (!visited[v] && map[u][v].time != inf) {
				if (map[u][v].time + minimumTime[u] < minimumTime[v] ||
					map[u][v].time + minimumTime[u] == minimumTime[v] && intersection[u] + 1 < intersection[v]) {
					previous[v] = u;
					minimumTime[v] = map[u][v].time + minimumTime[u];
					intersection[v] = intersection[u] + 1;
				}
			}
		}
	}
	vector<int> shortestTimePath = getPath(destination);
	int minTime = minimumTime[destination];
	if (shortestTimePath == shortestDisPath) {
		printf("Distance = %d; Time = %d: ", minDistance, minTime);
		for (int i = shortestTimePath.size() - 1;i >= 0;i--) {
			printf("%d", shortestTimePath[i]);
			if (i != 0)
				printf(" -> ");
		}
	}
	else {
		printf("Distance = %d: ", minDistance);
		for (int i = shortestDisPath.size() - 1;i >= 0;i--) {
			printf("%d", shortestDisPath[i]);
			if (i != 0)
				printf(" -> ");
		}
		printf("\n");
		printf("Time = %d: ", minTime);
		for (int i = shortestTimePath.size() - 1;i >= 0;i--) {
			printf("%d", shortestTimePath[i]);
			if (i != 0)
				printf(" -> ");
		}
	}
}

先求出所有最短路，再从中找出最佳路径，需要配合dfs求解：

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;

int intersectNum, streetNum;
int source, destination;
const int inf = 0x7fffffff;
struct node {
	int time, length;
	node() {
		time = inf;
		length = inf;
	}
}map[520][520];
bool visited[520] = { false };
int minimumDistance[520];
int minimumTime[520];
vector<int> previous[520];	//各结点的前驱结点

int minTime = inf;
vector<int> shortestDisPath;
void findMinDisPath(int cur, int curTime, vector<int> path) {
	if (cur == source) {
		if (curTime < minTime) {
			shortestDisPath = path;
			minTime = curTime;
		}
		return;
	}
	for (int i = 0;i < previous[cur].size();i++) {
		path.push_back(previous[cur][i]);
		findMinDisPath(previous[cur][i], curTime + map[previous[cur][i]][cur].time, path);
		path.pop_back();
	}
}

int minIntersection = inf;
vector<int> shortestTimePath;
void findMinTimePath(int cur, vector<int> path) {
	if (cur == source) {
		if (path.size() < minIntersection) {
			shortestTimePath = path;
			minIntersection = path.size();
		}
		return;
	}
	for (int i = 0;i < previous[cur].size();i++) {
		path.push_back(previous[cur][i]);
		findMinTimePath(previous[cur][i], path);
		path.pop_back();
	}
}

int main() {
	scanf("%d %d", &intersectNum, &streetNum);
	for (int i = 0;i < streetNum;i++) {
		int v1, v2, oneway, length, time;
		scanf("%d %d %d %d %d", &v1, &v2, &oneway, &length, &time);
		map[v1][v2].length = length;
		map[v1][v2].time = time;
		if (oneway == 0) {
			map[v2][v1].length = length;
			map[v2][v1].time = time;
		}
	}
	scanf("%d %d", &source, &destination);

	//Dijkstra找距离最短路
	fill(minimumDistance, minimumDistance + 520, inf);
	fill(visited, visited + 520, false);
	minimumDistance[source] = 0;
	for (int i = 0;i < intersectNum;i++) {
		int u = -1, minDis = inf;
		for (int j = 0;j < intersectNum;j++) {
			if (!visited[j] && minimumDistance[j] < minDis) {
				u = j;
				minDis = minimumDistance[j];
			}
		}
		if (u == -1)
			break;
		visited[u] = true;
		for (int v = 0;v < intersectNum;v++) {
			if (!visited[v] && map[u][v].length != inf) {
				if (map[u][v].length + minimumDistance[u] < minimumDistance[v]) {
					previous[v].clear();
					previous[v].push_back(u);
					minimumDistance[v] = map[u][v].length + minimumDistance[u];
				}
				else if (map[u][v].length + minimumDistance[u] == minimumDistance[v]) {
					previous[v].push_back(u);
				}
			}
		}
	}
	vector<int> temp;
	temp.push_back(destination);
	findMinDisPath(destination, 0, temp);

	//Dijkstra找时间最短路
	fill(minimumTime, minimumTime + 520, inf);
	fill(visited, visited + 520, false);
	for (int i = 0;i < 520;i++)
		previous[i].clear();
	minimumTime[source] = 0;
	for (int i = 0;i < intersectNum;i++) {
		int u = -1, minT = inf;
		for (int j = 0;j < intersectNum;j++) {
			if (!visited[j] && minimumTime[j] < minT) {
				u = j;
				minT = minimumTime[j];
			}
		}
		if (u == -1)
			break;
		visited[u] = true;
		for (int v = 0;v < intersectNum;v++) {
			if (!visited[v] && map[u][v].time != inf) {
				if (map[u][v].time + minimumTime[u] < minimumTime[v]) {
					previous[v].clear();
					previous[v].push_back(u);
					minimumTime[v] = map[u][v].time + minimumTime[u];
				}
				if (map[u][v].time + minimumTime[u] == minimumTime[v]) {
					previous[v].push_back(u);
				}
			}
		}
	}

	temp.clear();
	temp.push_back(destination);
	findMinTimePath(destination, temp);

	bool samePath = true;
	if (shortestDisPath.size() != shortestTimePath.size()) {
		samePath = false;
	}
	else {
		for (int i = 0;i < shortestDisPath.size();i++) {
			if (shortestDisPath[i] != shortestTimePath[i])
				samePath = false;
			break;
		}
	}
	if (shortestTimePath == shortestDisPath) {
		printf("Distance = %d; Time = %d: ", minimumDistance[destination], minimumTime[destination]);
		for (int i = shortestTimePath.size() - 1;i >= 0;i--) {
			printf("%d", shortestTimePath[i]);
			if (i != 0)
				printf(" -> ");
		}
	}
	else {
		printf("Distance = %d: ", minimumDistance[destination]);
		for (int i = shortestDisPath.size() - 1;i >= 0;i--) {
			printf("%d", shortestDisPath[i]);
			if (i != 0)
				printf(" -> ");
		}
		printf("\n");
		printf("Time = %d: ", minimumTime[destination]);
		for (int i = shortestTimePath.size() - 1;i >= 0;i--) {
			printf("%d", shortestTimePath[i]);
			if (i != 0)
				printf(" -> ");
		}
	}
}

二刷：
改用cin后比一刷代码的运行时间更长。

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
const int inf = 0x7fffffff;
int vertexNum, edgeNum, source, dest;
struct node {
	int length = inf, time = inf;
}map[500][500];
bool visited[500];
int totalLength[500];
int totalTime[500];
int totalVertex[500];
int shortestPreNode[500];
int fastestPreNode[500];
int main() {
	cin >> vertexNum >> edgeNum;
	for (int i = 0; i < edgeNum; i++) {
		int v1, v2, oneway, len, time;
		cin >> v1 >> v2 >> oneway >> len >> time;
		map[v1][v2].length = len;
		map[v1][v2].time = time;
		if (oneway == 0) {
			map[v2][v1].length = len;
			map[v2][v1].time = time;
		}
	}
	cin >> source >> dest;
	fill(visited, visited + 500, false);
	fill(totalLength, totalLength + 500, inf);
	fill(totalTime, totalTime + 500, inf);
	fill(shortestPreNode, shortestPreNode + 500, -1);
	totalTime[source] = 0;
	totalLength[source] = 0;
	for (int i = 0; i < vertexNum; i++) {
		int u = -1, minDis = inf;
		for (int j = 0; j < vertexNum; j++) {
			if (!visited[j] && totalLength[j] < minDis) {
				u = j;
				minDis = totalLength[j];
			}
		}
		if (u == -1) {
			break;
		}
		visited[u] = true;
		for (int v = 0; v < vertexNum; v++) {
			if (!visited[v] && map[u][v].length != inf) {
				if (totalLength[u] + map[u][v].length < totalLength[v]) {
					shortestPreNode[v] = u;
					totalTime[v] = totalTime[u] + map[u][v].time;
					totalLength[v] = totalLength[u] + map[u][v].length;
				}
				else if (totalLength[u] + map[u][v].length == totalLength[v]) {
					if (totalTime[v] > totalTime[u] + map[u][v].time) {
						shortestPreNode[v] = u;
						totalTime[v] = totalTime[u] + map[u][v].time;
					}
				}
			}
		}
	}
	vector<int> shortest;
	int cur = dest;
	while (cur != -1) {
		shortest.push_back(cur);
		cur = shortestPreNode[cur];
	}

	fill(fastestPreNode, fastestPreNode + 500, -1);
	fill(totalTime, totalTime + 500, inf);
	totalTime[source] = 0;
	fill(visited, visited + 500, false);
	fill(totalVertex, totalVertex + 500, inf);
	totalVertex[source] = 1;
	for (int i = 0; i < vertexNum; i++) {
		int u = -1, minTime = inf;
		for (int j = 0; j < vertexNum; j++) {
			if (!visited[j] && totalTime[j] < minTime) {
				minTime = totalTime[j];
				u = j;
			}
		}
		if (u == -1) {
			break;
		}
		visited[u] = true;
		for (int v = 0; v < vertexNum; v++) {
			if (!visited[v] && map[u][v].time != inf) {
				if (totalTime[u] + map[u][v].time < totalTime[v]) {
					fastestPreNode[v] = u;
					totalVertex[v] = totalVertex[u] + 1;
					totalTime[v] = totalTime[u] + map[u][v].time;
				}
				else if (totalTime[u] + map[u][v].time == totalTime[v]) {	//不同路径到达结点v的时间相等
					if (totalVertex[v] > totalVertex[u] + 1) {	//当前路径经过的结点数更少
						totalVertex[v] = totalVertex[u] + 1;
						fastestPreNode[v] = u;
					}
				}
			}
		}
	}
	cur = dest;
	vector<int> fastest;
	while (cur != -1) {
		fastest.push_back(cur);
		cur = fastestPreNode[cur];
	}

	if (fastest == shortest) {
		printf("Distance = %d; Time = %d: ", totalLength[dest], totalTime[dest]);
		for (int i = shortest.size() - 1; i >= 0; i--) {
			cout << shortest[i];
			if (i != 0) {
				cout << " -> ";
			}
		}
		cout << endl;
	}
	else {
		printf("Distance = %d: ", totalLength[dest]);
		for (int i = shortest.size() - 1; i >= 0; i--) {
			cout << shortest[i];
			if (i != 0) {
				cout << " -> ";
			}
		}
		cout << endl;
		printf("Time = %d: ", totalTime[dest]);
		for (int i = fastest.size() - 1; i >= 0; i--) {
			cout << fastest[i];
			if (i != 0) {
				cout << " -> ";
			}
		}
		cout << endl;
	}
}
ethannotlazy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ArcGis Map online
12-08
《ArcGIS Map Online：集成多元地图服务的高效工具》 ArcGIS Map Online 是一款强大的地理信息系统（GIS）软件，它允许用户快速加载并操作多种在线地图服务，包括谷歌地图、高德地图、天地图、搜搜地图以及必应地图...
online-map.zip
09-17
本文将深入探讨一个基于ArcGIS for iOS SDK的在线地图项目——"online-map.zip"，该项目实现了对主流地图平台的支持，包括但不限于百度地图。我们将详细解析其核心功能和实现原理，同时关注与Objective-C编程相关的...
1111 Online Map
mike___mike的博客
02-14 191
题目：Online Map 题意描述： 题目要求给出两条路径，一条路程最短，一条时间最短。 如果最短路程相同，则选取时间最短的那条（不要和和单纯时间最短混淆）； 如果最短时间相同，选取边数最少的那条。 思路： 利用Dijkstra算法，这里维护两个vis数组，一个是最短路径的，一个是最短时间的，然后在一次Dijkstra中，分别对最短路径和最短时间的相关量做更新。 disVis,te...
PAT甲级 1111 Online Map(30分) dijkstra/C++
qq_43955154的博客
06-01 127
1111 Online Map (30分) 题目大意：给定一个地图，以及源点和目的地点，求出距离最短和时间最短的路径 tips： 路线有单行道和双行道 有相同最短距离路线时，选择时间最短的。有相同时间最短路线时，选择中转站最少的（经过结点最少） 两次dijkstra搜索最短路径： #include<iostream> //输入输出流头文件 #include<stack> //栈 using namespac
1111 Online Map (30 分)（纯粹的迪杰斯特拉，详解）
weixin_45962741的博客
12-13 132
Input our current position and a destination, an online map can recommend several paths. Now your job is to recommend two paths to your user: one is the shortest, and the other is the fastest. It is guaranteed that a path exists for any request. Input Spec
1111 Online Map （30 分）--PAT甲级
laplacebh的博客
01-24 837
1111 Online Map （30 分） Input our current position and a destination, an online map can recommend several paths. Now your job is to recommend two paths to your user: one is the shortest, and the other ...
ditie.rar_Beijing map online_地铁
09-20
北京地铁地图在线查看，动画演示图，地图可放大缩小，基于FLASH，你需要打开 sbw.js这个文件，搜索一下 lvtao.net 换成你的域名即可网上使用，否则不能用的，扣的办法就是火狐浏览器/firebug 加个下载工具。...
Online Maps v3.5.rar
04-27
《Unity中的在线地图系统——Online Maps v3.5详解》 Unity引擎作为一款强大的跨平台游戏开发工具，广泛应用于游戏开发、虚拟现实(VR)、增强现实(AR)等领域。在这些项目中，地图系统往往是不可或缺的一部分，它帮助...
online map 很好使的2d地图
12-22
Q6195 Online Maps v3 3.7.5.2.unitypackage作为一个专门的插件，为开发者提供了便利的集成工具，降低了开发难度，使得在Unity中构建地图应用变得更加容易。通过不断学习和实践，开发者可以更好地掌握这一技术，为...
OnlineMap-MapInfo插件.rar
11-17
GCITool-MapInfo分扇区插件，查看临小区插件，很实用的小工具。网络优化过程中必备的插件。 OnlineMap-MapInfo在线地图插件。
Mapinfo在线地图插件-OnlineMap.MBX
05-31
Mapinfo在线地图工具V1.4.1破解版，无需注册，绝对可用！ 1、先打开Mapinfo插件：OnlineMap.MBX(可在mapinfo中设置自动加载插件) 2、在插件中点击 ：运行在线地图工具 打开在线地图 3、点击关闭图层：暂时关闭在线地图图层 4、关闭图层后，可点击加载图层 重新加载图层
Online Maps v3 3.7.15版本
最新发布
05-29
1.Online Maps 是适用于 2D、3D、AR/VR 和移动应用程序和游戏的通用多平台地图解决方案。 完全可自定义，非常易于学习和使用，同时也是业界最强大且最灵活的解决方案之一。 2.渲染管线：标准 RP、URP、HDRP； 3.独立...
unity在线地图Online Maps
11-07
unity在线地图Online Maps 2.5.16 需Unity 4.6.0或以上版本 Requires Unity 4.6.0 or higher. Features: ? Supports Unity v4.6+, Unity v5+; ? Standalone, Android, iOS, Windows Store, WebGL, Webplayer;...
Online Maps v3.7.unitypackage
01-20
Online Maps 是适用于 2D、3D、AR/VR 和移动应用程序和游戏的通用多平台地图解决方案。 完全可自定义，非常易于学习和使用，同时也是业界最强大且最灵活的解决方案之一。 支持大量服务，可满足任何地图制图需求，并...
PAT 甲级 1111 Online Map (30 分)
Yuhan的博客
09-07 368
思路： 1.两次dijskra即可，用dfs会超时，我剪枝剪了好久还是会超时… 2.每次判断是否最短(最快)的时候依据题目中的两个标准； 3.用vector保存每个点可达的下一个点，用邻接矩阵存储距离和时间，用数组标记每个点是否已知最短(最快)，用数组记录每个点此刻离起点的距离、最短路径的最短可达时间、最短时间、最短时间的最少周转次数，再用数组保存每个点的最短路径前驱结点和最短时间前驱结点； 4....
A1111 Online Map (30 分| Dijkstra算法| dfs深度搜索，附详细注释，逻辑分析)
kngines
09-08 185
写在前面 思路分析 给1张地图，两个结点中既有距离也有时间，有单行有双向，要求根据地图推荐两条路线： 1条最快到达路线，1条最短距离路线。 第1行给出2个整数N和M，表示地图中地点个数和路径条数。 接下来M行每1行给出： 道路结点编号V1 道路结点编号V2 是否单行线 道路长度 所需时间 要求第1行输出最快到达时间Time和路径，第2行输出最短距离Distance和路径 分析： ...
(1)读取online_retail.csv数据并创建 RDD的代码是什么。 (2)通过 map()方法分制数据，选择客户编号和订单价格字段组成键值对数据的代码是什么 (3)使用 reduceByKey()方法计算每位客户的总消费金额的代码是什么 (4)使用sortBy()方法对每位客户的总消费金额进行降序排序，取出前 50 条数据的代码是什么
06-03
(1) 读取 online_retail.csv 数据并创建 RDD 的代码： ```scala val spark = SparkSession.builder() .appName("Online Retail") .master("local[*]") .getOrCreate() val sc = spark.sparkContext val rdd = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值