L3-007 天梯地图 (30 分)（两个最短路径）（代码有解析）

L3-007 天梯地图 (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

/*
	解题思路：两个迪杰特斯拉算法求最短路径和最短时间 
*/ 
#include<bits/stdc++.h>
using namespace std;
const int maxn=510;
const int inf=0x3f3f3f3f;  
int T_time[maxn][maxn],T_weigh[maxn][maxn]; //分别存放时间权值和路径权值 
int D_time[maxn],D_weigh[maxn];//分别存放各个点到起始点的最短时间和最短距离的值 
int P_time[maxn],P_weigh[maxn];//分别存放各个点在取得最短时间和最短路径后的上一个节点 
int n,m;//节点和路径个数 
int Point[maxn];//存放在点取得最短距离后，该点到初始点之间含有的节点个数 
int Length[maxn];//存放在点取得最短时间后，该点到初始点之间的距离 
int flag_t[maxn]={false},flag_w[maxn]={false};//两个标记数组 

void DJS_weigh(int a)//求起始点到各个点的最短路径 
{
	//基本上就是最短路径算法，没有什么大的变动 
	for(int i=0;i<n;i++)
	{
		Point[i]=1;//初始化Point 
		
		D_weigh[i]=T_weigh[a][i];
		if(D_weigh[i]!=inf)
		{
			P_weigh[i]=a;
			Point[i]+=1;
		}
		else P_weigh[i]=-1;
	}
	flag_w[a]=true;
	for(int i=0;i<n;i++)
	{
		int mini=inf,minid=-1;
		for(int j=0;j<n;j++)
		{
			if(!flag_w[j]&&D_weigh[j]<mini)
			{
				mini=D_weigh[j];
				minid=j;
			}
		}
		if(minid==-1) return ;
		flag_w[minid]=true;
		for(int j=0;j<n;j++)
		{
			if(!flag_w[j]&&T_weigh[minid][j]!=inf)
			{
				if(D_weigh[j]>D_weigh[minid]+T_weigh[minid][j])
				{
					D_weigh[j]=D_weigh[minid]+T_weigh[minid][j];
					P_weigh[j]=minid;
					Point[j]=Point[minid]+1;//节点+1 
				}
				else if(D_weigh[j]==D_weigh[minid]+T_weigh[minid][j])//如果权值相等 
				{
					if(Point[minid]+1<Point[j])//取最少节点 
					{
						Point[j]=Point[minid]+1;
						P_weigh[j]=minid;
					}
				}
			}
		}
	}
}

void DJS_time(int a)//求起始点到各个点的最短时间 
{
	//基本上就是最短路径算法，没有什么大的变动 
	for(int i=0;i<n;i++)
	{
		//这里没有Length的初始化 
		D_time[i]=T_time[a][i];
		if(D_time[i]!=inf)
		{
			Length[i]+=T_weigh[a][i];
			P_time[i]=a;
		}
		else P_time[i]=-1;
	}
	flag_t[a]=true;
	for(int i=0;i<n;i++)
	{
		int mini=inf,minid=-1;
		for(int j=0;j<n;j++)
		{
			if(!flag_t[j]&&D_time[j]<mini)
			{
				mini=D_time[j];
				minid=j;
			}
		}
		flag_t[minid]=true;
		for(int j=0;j<n;j++)
		{
			if(!flag_t[j]&&T_time[minid][j]!=inf)
			{
				if(D_time[j]>D_time[minid]+T_time[minid][j])//如果权值相等 
				{
					D_time[j]=D_time[minid]+T_time[minid][j];
					P_time[j]=minid;
					Length[j]=Length[minid]+T_weigh[minid][j];
				}
				else if(D_time[j]==D_time[minid]+T_time[minid][j])
				{
					if(Length[minid]+T_weigh[minid][j]<Length[j])//取两点间距离最短的 
					{
						Length[j]=Length[minid]+T_weigh[minid][j];
						P_time[j]=minid;
					}
				}
			}
		}
	}
}
int main(void)
{
	cin>>n>>m;
	memset(T_time,0x3f,sizeof(T_time));
	memset(T_weigh,0x3f,sizeof(T_weigh));
	memset(D_time,0x3f,sizeof(D_time));
	memset(D_weigh,0x3f,sizeof(D_weigh));
	memset(Length,0,sizeof(Length));//Length的初始化 
	
	for(int i=0;i<m;i++)
	{
		int a,b,flag,w,t;
		cin>>a>>b>>flag>>w>>t;
		T_time[a][b]=t;
		T_weigh[a][b]=w;
		if(!flag)//flag==0代表路是双向的 
		{
			T_time[b][a]=t;
			T_weigh[b][a]=w;
		}
	}
	int start,last;//初始点、终点 
	cin>>start>>last;
	DJS_weigh(start);
	DJS_time(start);
	
	stack<int> st,sw;//用stack往回存节点 
	int temp_t=last,temp_w=last;
	while(temp_t!=-1)
	{
		st.push(temp_t);
		temp_t=P_time[temp_t];
	}
	while(temp_w!=-1)
	{
		sw.push(temp_w);
		temp_w=P_weigh[temp_w];
	}
	
	//结果输出 
	if(sw==st)//如果节点相等 
	{
		cout<<"Time = "<<D_time[last]<<"; Distance = "<<D_weigh[last]<<": ";
		while(!sw.empty())
		{
			cout<<sw.top();
			sw.pop();
			if(!sw.empty()) cout<<" => ";
		}
	}
	else
	{
		cout<<"Time = "<<D_time[last]<<": ";
		while(!st.empty())
		{
			cout<<st.top();
			st.pop();
			if(!st.empty()) cout<<" => ";
		}
		cout<<endl;
		cout<<"Distance = "<<D_weigh[last]<<": ";
		while(!sw.empty())
		{
			cout<<sw.top();
			sw.pop();
			if(!sw.empty()) cout<<" => ";
		}
		cout<<endl;
	}
	return 0;
}