PTA天梯 L3-007 天梯地图

L3-007 天梯地图

题目：

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

输入格式：

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

解题思路：

首先是建图，然后求两次最短路径。

因为求最快的路时要用到最短的路，所以先求最短的路，再求最快的路。

用pre记录每个节点的上一个节点来记录路径。

用到的是 图的最短路径算法，这里用的是dijkstra算法。

代码：

起点Start，Len[k]表示从start到k的最短路径，用preL[k]记录k的前驱点。

根据题意，变异dijkstra算法：如果最快到达路线不唯一，则输出几条最快路线中最短的那条。如果最短距离的路线不唯一，则输出途径节点数最少的那条。

 #include <cstdio>
 #include <cstring>
 #include <stack>
 #include <iostream>
 #include <algorithm>
 #define N 505
 using namespace std;

 int maxint = ;
 int n, Start, End, i, j;
 bool vis[N];    //标记是否访问过
 int mapL[N][N];    //记录距离的伴随矩阵
 int mapT[N][N];    //记录时间的伴随矩阵
 int Len[N];        //Start到k 的最短距离
 int Time[N];    //Start到k 的最少时间
 int preL[N];    //最短距离路径前驱
 int preT[N];    //最少时间路径前驱

 //Dijstra算法求最短距离，修改后以符合题意
 void Dijstra_Len(){
     int step[N];
     memset(step, , sizeof(step));
     step[Start] = ;
     //step记录节点数
     memset(vis, , sizeof(vis));
     Len[Start] = ;
     while(){
         int minl = maxint, k;
         //在没有被访问过的点中找一个顶点k,使len[k]最小
         for(i = ;i < n; i++){
             if(vis[i] && minl > Len[i]){
                 minl = Len[i];
                 k = i;
             }
         }
         //如果所有点都已经访问过，则结束遍历
         if(minl == maxint)break;
         //顶点k 标记为已确定（start 到达k 的最短路径）
         vis[k] = ;
         //遍历与k 相连的每个未确定最短路径的顶点j
         for(i = ;i < n; i++){
             int d = Len[k] + mapL[k][i];
             if(vis[i] && Len[i] > d){
                 Len[i] = d;
                 preL[i] = k;
                 step[i] = step[k]+;
             //当路径距离相等时，优先记录节点数少的路径
             }else if(vis[i] && Len[i] == d && step[k]+ < step[i]){
                 preL[i] = k;
                 step[i] = step[k]+;
             }
         }
     }
 }

 //Dijstra算法求最少时间，修改后以符合题意
 void Dijstra_Time(){
     memset(vis, , sizeof(vis));
     //用于记录距离长度
     int dis[N];
     for(i = ;i < n; i++)
         dis[i] = mapL[Start][i];
     Time[Start] = ;
     dis[Start] = ;
     while(){
         int minl = maxint, k;
         for(i = ;i < n; i++){
             if(vis[i] && minl > Time[i]){
                 minl = Time[i];
                 k = i;
             }
         }
         if(minl == maxint)break;
         vis[k] = ;
         for(i = ;i < n; i++){
             int t = Time[k]+mapT[k][i];
             int d = dis[k]+mapL[k][i];
             if(vis[i] && Time[i] > t){
                 dis[i] = d;
                 Time[i] = t;
                 preT[i] = k;
             //当时间相同时，保存其中距离最短的
             }else if(vis[i] && Time[i] == t && dis[i] > d){
                 dis[i] = d;
                 preT[i] = k;
             }
         }
     }
 }

 int main(){
     memset(preL, -, sizeof(preL));
     memset(preT, -, sizeof(preT));
     int m;
     cin >> n >> m;
     for(i = ;i < n; i++){
         Len[i] = maxint;
         Time[i] = maxint;
         for(int j = ;j < n;++j){
             mapL[i][j] = maxint;
             mapT[i][j] = maxint;
         }
     }
     while(m--){
         int x, y, t;
         cin >> x >> y >> t;
         cin >> mapL[x][y] >> mapT[x][y];
         if(!t){
             mapL[y][x] = mapL[x][y];
             mapT[y][x] = mapT[x][y];
         }
     }
     cin >> Start >> End;
     Dijstra_Len();
     Dijstra_Time();
     //取出前驱节点里保存的路径，装入stack中
     stack<int> bestT, bestL;
     i = End;
     while(i != Start){
         bestT.push(i);
         i = preT[i];
     }
     i = End;
     while(i != Start){
         bestL.push(i);
         i = preL[i];
     }
     //按题意要求输出
     if(bestL == bestT){
         printf("Time = %d; Distance = %d: %d",Time[End], Len[End], Start);
         while(!bestL.empty()){
             int t = bestL.top();
             cout << " => " << t;
             bestL.pop();
         }cout << endl;
     }else {
         cout << "Time = " << Time[End] << ": " << Start;
         while(!bestT.empty()){
             int t = bestT.top();
             cout << " => " << t;
             bestT.pop();
         }
         cout << endl << "Distance = " << Len[End] << ": " << Start;
         while(!bestL.empty()){
             int t = bestL.top();
             cout << " => " << t;
             bestL.pop();
         }cout << endl;
     }

     return ;
 }