PTA-天梯地图

7-25 天梯地图

分数 30

全屏浏览题目切换布局

作者 陈越

单位 浙江大学

本题要求你实现一个天梯赛专属在线地图，队员输入自己学校所在地和赛场地点后，该地图应该推荐两条路线：一条是最快到达路线；一条是最短距离的路线。题目保证对任意的查询请求，地图上都至少存在一条可达路线。

输入格式：

输入在第一行给出两个正整数N（2 ≤ N ≤ 500）和M，分别为地图中所有标记地点的个数和连接地点的道路条数。随后M行，每行按如下格式给出一条道路的信息：

V1 V2 one-way length time

其中V1和V2是道路的两个端点的编号（从0到N-1）；如果该道路是从V1到V2的单行线，则one-way为1，否则为0；length是道路的长度；time是通过该路所需要的时间。最后给出一对起点和终点的编号。

输出格式：

首先按下列格式输出最快到达的时间T和用节点编号表示的路线：

Time = T: 起点 => 节点1 => ... => 终点

然后在下一行按下列格式输出最短距离D和用节点编号表示的路线：

Distance = D: 起点 => 节点1 => ... => 终点

如果最快到达路线不唯一，则输出几条最快路线中最短的那条，题目保证这条路线是唯一的。而如果最短距离的路线不唯一，则输出途径节点数最少的那条，题目保证这条路线是唯一的。

如果这两条路线是完全一样的，则按下列格式输出：

Time = T; Distance = D: 起点 => 节点1 => ... => 终点

输入样例1：

10 15
0 1 0 1 1
8 0 0 1 1
4 8 1 1 1
5 4 0 2 3
5 9 1 1 4
0 6 0 1 1
7 3 1 1 2
8 3 1 1 2
2 5 0 2 2
2 1 1 1 1
1 5 0 1 3
1 4 0 1 1
9 7 1 1 3
3 1 0 2 5
6 3 1 2 1
5 3

输出样例1：

Time = 6: 5 => 4 => 8 => 3
Distance = 3: 5 => 1 => 3

输入样例2：

7 9
0 4 1 1 1
1 6 1 3 1
2 6 1 1 1
2 5 1 2 2
3 0 0 1 1
3 1 1 3 1
3 2 1 2 1
4 5 0 2 2
6 5 1 2 1
3 5

输出样例2：

Time = 3; Distance = 4: 3 => 2 => 5

代码长度限制

16 KB

时间限制

300 ms

内存限制

64 MB

思路

虽然能想到是两个dijkstra，但是注意题目给定的条件，即 “如果最快到达路线不唯一，则输出几条最快路线中最短的那条，题目保证这条路线是唯一的。而如果最短距离的路线不唯一，则输出途径节点数最少的那条，题目保证这条路线是唯一的。”，所以我们在跑dijkstra的时候，如果碰到两个点的时间或路径相等的话也应该进行计数，这里计数（访问了几个点，其实相当于边权为1的迪杰斯特拉吗，这样也好理解），路径不能用已知最短路径）

#include <iostream>
#include <vector>
#include <cstring>
#define rep(i, j, k) for(int i = j; i <= k; i ++)
using namespace std;

const int N = 600;

int n, m;


int v1[N][N], v2[N][N], cnt[N];

void add(int a, int b, int len, int time){
	v1[a][b] = min(v1[a][b], len);
	v2[a][b] = min(v2[a][b], time);
}

int dist[N], tim[N], pre[N], pre2[N], s, ed;
vector<int> path1, path2;
bool st[N];

void dijkstra(){
	memset(dist, 0x3f, sizeof dist);
	memset(st, 0, sizeof st);
	dist[s] = 0;
	rep (i, 1, n - 1){
		int u = -1;
		rep(j, 0, n - 1)
			if(!st[j] && (u == -1 || dist[j] < dist[u])) 
				u = j;
		st[u] = 1;
		rep(i, 0, n - 1){
			if(dist[i] > dist[u] + v1[u][i]){
				dist[i] = dist[u] + v1[u][i];
				pre[i] = u;
				cnt[i] = cnt[u] + 1;
			} else if(dist[i] == dist[u] + v1[u][i]) {
				if(cnt[i] > cnt[u] + 1) {
					dist[i] = dist[u] + v1[u][i];
					pre[i] = u;
					cnt[i] = cnt[u] + 1;
				}
			}
		}
	}
}

void dijkstra2(){
	memset(tim, 0x3f, sizeof tim);
	memset(dist, 0x3f, sizeof dist);
	memset(st, 0, sizeof st);
	tim[s] = 0;
	rep (i, 1, n){
		int u = -1;
		rep (j, 0, n - 1)
			if (!st[j] && (u == -1 || tim[j] < tim[u]))
				u = j;
		st[u] = 1;
		rep(i, 0, n - 1) {
			if(tim[i] > tim[u] + v2[u][i]) {
				tim[i] = tim[u] + v2[u][i];
				pre2[i] = u;
				dist[i] = dist[u] + v1[u][i];
			} else if(tim[i] == tim[u] + v2[u][i]) {
				if(dist[i] > dist[u] + v1[u][i]) {
					tim[i] = tim[u] + v2[u][i];
					pre2[i] = u;
					dist[i] = dist[u] + v1[u][i];
				}
			}
		}
	}
}

void dfs_paths(int u){
	if (u == s){
		// printf("Distance = %d: %d", dist[ed], u);
		path1.push_back(s);
		return;
	}
	dfs_paths(pre[u]);
	// printf(" => %d", u);
	path1.push_back(u);
}

void dfs_paths2(int u){
	if (u == s){
		// printf("Time = %d: %d", tim[ed], u);
		path2.push_back(s);
		return;
	}
	dfs_paths2(pre2[u]);
	// printf(" => %d", u);
	path2.push_back(u);
}


void dfs_path(int u){
	if (u == s){
		printf("Distance = %d: %d", dist[ed], u);
		return;
	}
	dfs_path(pre[u]);
	printf(" => %d", u);
}

void dfs_path2(int u){
	if (u == s){
		printf("Time = %d: %d", tim[ed], u);
		return;
	}
	dfs_path2(pre2[u]);
	printf(" => %d", u);
}

int main() {
	memset(v1, 0x3f, sizeof v1);
	memset(v2, 0x3f, sizeof v2);
	cin >> n >> m;
	for(int i = 1; i <= m; i ++) {
		int a, b, c, d, e;
		cin >> a >> b >> c >> d >> e;
		add(a, b, d, e);
		if(!c) add(b, a, d, e);
	}
	cin >> s >> ed;
	dijkstra2();
	// cout << tim[ed] << endl;
	// cout << pre2[ed];
	dfs_paths2(ed);
	// puts("");
	dijkstra();
	// cout << dist[ed];
	dfs_paths(ed);
	if(path1.size() == path2.size()) {
		bool ok = true;
		for(int i = 0; i < path1.size(); i ++) {
			if(path1[i] != path2[i]) ok = false;
		}
		if(ok) {
			printf("Time = %d; Distance = %d: ", tim[ed], dist[ed]);	
			cout << path1[0];
			for(int i = 1; i < path1.size(); i ++) {
				cout << " => " << path1[i];
			}
			return 0;
		}
	}
    dfs_path2(ed);
    puts("");
	dfs_path(ed);
}