L3-007 天梯地图 （30 分)

题目来源：PTA

题目链接：https://pintia.cn/problem-sets/994805046380707840/problems/994805051153825792

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

输入格式：

输入在第一行给出两个正整数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

思路

分别用时间和路程跑2次最短路， 我用的是dijkstra算法。但要注意：找最快的最短，不能直接用最短路径数组；找最短的节点最少，模拟最短路把各个节点距离记为1

代码

#include <bits/stdc++.h>
using namespace std;
#define LL long long

int n, m;
/*
	访问数组 
*/ 
int vis[505];
/*
	dp_l：存放最短距离 
	root：记录节点个数
	Len：原图路径
	paht_l：记录路径 
*/
int dp_l[505], root[505], Len[505][505], path_l[505];
/*
	dp_l：存放最短时间 
	ymk：记录按时间跑dijkstra得到的最短路径（千万不能用dp_l判断） 
	Time：原图时间
	paht_l：记录路径 
*/
int dp_t[505], Time[505][505], path_t[505], ymk[505];

//根据时间跑一遍dijkstra 
void Dijkstra_t(int s, int e)
{
	memset(vis, 0, sizeof(vis));
	memset(ymk, 0x3f3f3f3f, sizeof(ymk));
	for(int i=0; i<n; i++)
	{
		dp_t[i] = Time[s][i];
		ymk[i] = Len[s][i];
	}
	ymk[s] = dp_t[s] = 0;
	for(int i=0; i<n; i++)
	{
		int Min = 0x3f3f3f3f, mark;
		for(int j=0; j<n; j++)
		{
			if(Min>dp_t[j] && !vis[j])
			{
				Min = dp_t[j];
				mark = j;
			}
		}
		vis[mark] = 1;
		for(int j=0; j<n; j++)
		{
			if(vis[j])
				continue;
			if(dp_t[j] > dp_t[mark]+Time[mark][j])	//每次找最短时间 
			{
				dp_t[j] = dp_t[mark]+Time[mark][j];
				path_t[j] = mark;
				ymk[j] = ymk[mark]+Len[mark][j];
			}
			else if(dp_t[j] == dp_t[mark]+Time[mark][j])	//时间相同时取最短路径 
			{
				if(ymk[j] > ymk[mark]+Len[mark][j])
				{
					path_t[j] = mark;
					ymk[j] = ymk[mark]+Len[mark][j];
				}
			}
		}
	}
}

//根据路径跑一遍dijkstra 
void Dijkstra_l(int s, int e)
{
	//初始化访问数组 
	memset(vis, 0, sizeof(vis));
	memset(root, 0, sizeof(root));
	for(int i=0; i<n; i++)
		dp_l[i] = Len[s][i];
	dp_l[s] = 0;
	for(int i=0; i<n; i++)
	{
		int Min = 0x3f3f3f3f, mark;
		for(int j=0; j<n; j++)
		{
			if(Min>dp_l[j] && !vis[j])
			{
				Min = dp_l[j];
				mark = j;
			}
		}
		vis[mark] = 1;
		for(int j=0; j<n; j++)
		{
			if(vis[j])
				continue;
			if(dp_l[j] > dp_l[mark]+Len[mark][j])	//每次找最短路径 
			{
				dp_l[j] = dp_l[mark]+Len[mark][j];
				root[j] = root[mark]+1;
				path_l[j] = mark;
			}
			else if(dp_l[j] == dp_l[mark]+Len[mark][j])	//路径相同时，取最短节点个数 
			{
				if(root[j]>root[mark]+1)
				{
					root[j] = root[mark]+1;	//节点数用各个点路径为1模拟 
					path_l[j] = mark;
				}
			}
		}
	}
}

//初始化 
void init()
{
	memset(Time, 0x3f3f3f3f, sizeof(Time));
	memset(Len, 0x3f3f3f3f, sizeof(Len));
	memset(path_l, -1, sizeof(path_l));
	memset(path_t, -1, sizeof(path_t));
} 

int main()
{
	ios::sync_with_stdio(false);
	init();
	cin >> n >> m;
	while(m--)
	{
		int v1, v2, way, l, t;
		cin >> v1 >> v2 >> way >>l >> t;
		if(way == 1)
		{
			Time[v1][v2] = t;
			Len[v1][v2] = l;
		}
		else
		{
			Time[v1][v2] = Time[v2][v1] = t;
			Len[v1][v2] = Len[v2][v1] = l;
		}
	}
	int s, e;
	cin >> s >> e;
	Dijkstra_l(s, e);
	Dijkstra_t(s, e);
	
	//读取输出的路径并比较 
	vector<int> vec_l, vec_t;
	int mid = e;
	while(mid != -1)
	{
		vec_l.push_back(mid);
		mid = path_l[mid];
	}
	mid = e;
	while(mid != -1)
	{
		vec_t.push_back(mid);
		mid = path_t[mid];
	}
	//初始节点 
	vec_t.push_back(s);
	vec_l.push_back(s);
	if(vec_t == vec_l)
	{
		cout << "Time = " << dp_t[e] << "; Distance = " << dp_l[e] << ": ";
		int c = 0;
		for(int i=vec_t.size()-1; i>=0; i--)
		{
			if(c)
				cout << " => ";
			c = 1;
			cout << vec_t[i];
		}
	}
	else
	{
		cout << "Time = " << dp_t[e] << ": ";
		int c = 0;
		for(int i=vec_t.size()-1; i>=0; i--)
		{
			if(c)
				cout << " => ";
			c = 1;
			cout << vec_t[i];
		}
		cout << endl;
		cout << "Distance = " << dp_l[e] << ": ";
		c = 0;
		for(int i=vec_l.size()-1; i>=0; i--)
		{
			if(c)
				cout << " => ";
			c = 1;
			cout << vec_l[i];
		}
	}
}