PAT甲级——1131 Subway Map （30 分)

可以转到我的CSDN查看同样的文章https://blog.csdn.net/weixin_44385565/article/details/89003683

1131 Subway Map （30 分)

In the big cities, the subway systems always look so complex to the visitors. To give you some sense, the following figure shows the map of Beijing subway. Now you are supposed to help people with your computer skills! Given the starting position of your user, your task is to find the quickest way to his/her destination.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (≤ 100), the number of subway lines. Then N lines follow, with the i-th (,) line describes the i-th subway line in the format:

M S[1] S[2] ... S[M]

where M (≤ 100) is the number of stops, and S[i]'s (i=1,⋯,M) are the indices of the stations (the indices are 4-digit numbers from 0000 to 9999) along the line. It is guaranteed that the stations are given in the correct order -- that is, the train travels between S[i] and S[i+1] (i=1,⋯,M−1) without any stop.

Note: It is possible to have loops, but not self-loop (no train starts from S and stops at S without passing through another station). Each station interval belongs to a unique subway line. Although the lines may cross each other at some stations (so called "transfer stations"), no station can be the conjunction of more than 5 lines.

After the description of the subway, another positive integer K (≤ 10) is given. Then K lines follow, each gives a query from your user: the two indices as the starting station and the destination, respectively.

The following figure shows the sample map.

Note: It is guaranteed that all the stations are reachable, and all the queries consist of legal station numbers.

Output Specification:

For each query, first print in a line the minimum number of stops. Then you are supposed to show the optimal path in a friendly format as the following:

Take Line#X1 from S1 to S2.
Take Line#X2 from S2 to S3.
......

where Xi's are the line numbers and Si's are the station indices. Note: Besides the starting and ending stations, only the transfer stations shall be printed.

If the quickest path is not unique, output the one with the minimum number of transfers, which is guaranteed to be unique.

Sample Input:

Sample Output:

Take Line# from  to .

Take Line# from  to .
Take Line# from  to .
Take Line# from  to .

Take Line# from  to .
Take Line# from  to .
Take Line# from  to .

题目大意：求最短路径（停靠站点次数最少的路径），停靠站点次数相同时选择转站次数最少的路径。

思路：这是一个有环无向图，需要开辟一个visit映射（或者数组）来标记已经访问过的节点，回溯的时候再更改标记。用unordered_map来存储每两个站点之间的地铁线路，用于中转站的判断（前面的节点到当前节点的线路与当前节点到后一节点的线路不同的话那么当前节点为中转站）。DFS里面设置一个临时路径tpath（存储当前的路径），搜索的过程中，每一次到达destination的时候都对临时路径进行判断，使得最终路径path始终指向当前的最短路径。。。题目虽然不难，但是相当的繁琐~~

 #include<iostream>
 #include<vector>
 #include<unordered_map>
 using namespace std;

 unordered_map<int,vector<int>> G;//G存储无向图信息
 unordered_map<int,int> Line;//Line存储每两个站点间的线路信息

 int mintrans,minsite;//最少转站次数、最少过站次数
 /*DFS传递的参数很多，但是全局变量也不是很方便*/
 void DFS(unordered_map<int,bool> &visit,vector<int> &path,vector<int> &tpath,int start,int &end,int sitecnt);
 int transferNum(vector<int> &tpath);//获取路径的中转站数量 

 int main()
 {
     int N,M,K;
     scanf("%d",&N);
     for(int i=;i<=N;i++){
         int pre,cur;
         scanf("%d%d",&M,&pre);
         for(int j=;j<M;j++){
             scanf("%d",&cur);
             G[pre].push_back(cur);
             G[cur].push_back(pre);
             Line[pre*+cur]=Line[cur*+pre]=i;
             pre=cur;
         }
     }
     scanf("%d",&K);
     for(int i=;i<K;i++){
         int start,end,sitecnt=;
         mintrans=,minsite=;//数据初始化
         scanf("%d%d",&start,&end);
         vector<int> path,tpath;//path存储最终路径，tpath存储临时路径
         unordered_map<int,bool> visit;//标记访问过的节点
         DFS(visit,path,tpath,start,end,sitecnt);
         /*输出结果*/
         int preline=Line[path[]*+path[]],presite=start,f=path.size();
         printf("%d\n",f-);
         for(int j=;j<f;j++){
             int tmpline=Line[path[j-]*+path[j]];
             if(preline!=tmpline){
                 printf("Take Line#%d from %04d to %04d.\n",preline,presite,path[j-]);
                 presite=path[j-];
                 preline=tmpline;
             }
         }
         if(preline==Line[path[f-]*+path[f-]])//终点站属于中转站的时候要记得输出
            printf("Take Line#%d from %04d to %04d.\n",preline,presite,end);
     }
     return ;
  }
 int transferNum(vector<int> &tpath)
 {
     int pre=Line[tpath[]*+tpath[]],transcnt=;
     for(int i=;i<tpath.size();i++){
         int tmp=Line[tpath[i-]*+tpath[i]];
         if(pre!=tmp) transcnt++;
         pre=tmp;
     }
     return transcnt;
 }
 void DFS(unordered_map<int,bool> &visit,vector<int> &path,vector<int> &tpath,int start,int &end,int sitecnt)
 {
     if(!visit[start]){
         visit[start]=true;
         tpath.push_back(start);
     }
     if(start==end){
         int transcnt=transferNum(tpath);
         if(minsite>sitecnt||(minsite==sitecnt&&mintrans>transcnt)){//找到比当前路径的站点数更少、转站数更少的路径则替换路径
             minsite=sitecnt;
             mintrans=transcnt;
             path=tpath;
         }
         return;//到达终点则结束当前维度的搜索
     }
     for(int i=;i<G[start].size();i++){
         if(!visit[G[start][i]]){
             DFS(visit,path,tpath,G[start][i],end,sitecnt+);
             visit[G[start][i]]=false;
             tpath.pop_back();
         }
     }
 }