1131 Subway Map (30 分)--------C语言

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 (i=1,⋯,N) 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:

4
7 1001 3212 1003 1204 1005 1306 7797
9 9988 2333 1204 2006 2005 2004 2003 2302 2001
13 3011 3812 3013 3001 1306 3003 2333 3066 3212 3008 2302 3010 3011
4 6666 8432 4011 1306
3
3011 3013
6666 2001
2004 3001

结尾无空行

Sample Output:

2
Take Line#3 from 3011 to 3013.
10
Take Line#4 from 6666 to 1306.
Take Line#3 from 1306 to 2302.
Take Line#2 from 2302 to 2001.
6
Take Line#2 from 2004 to 1204.
Take Line#1 from 1204 to 1306.
Take Line#3 from 1306 to 3001.

当时做这道题的时候主要遇到两个问题：

1、怎么表示这个图，毕竟这一个站台有多个邻接点，矩阵和链表明显都不行

2、怎么判断是不是中转站，或者说怎么知道哪些站台在哪条线路上

后来看了大佬的代码之后，终于解决了这两个问题。

        第一个问题：采用unordered_map <int, vector <int> > G（注意别用map容器，因为map容器会默认排序，排序会消耗时间，在这里没必要，并且会运行超时），关键字为站台代码，后面vector容器就可以存和这个站台的多个邻接点了；或者说采用vector <int> Adj[Maxsize]，下标为站台代码，因为是vector容器，所以也可以在对应下标下存储多个邻接点代码。

        第二个问题：采用将两个四位数代码合并成一个八位数来表示线路：

unordered_map<int, int> Line；

unordered_map <int, vector <int> > G；

void CreatG_Line(void)
{
    int M=0, i=0, j=0;
    for(i=1;i<=N;i++){
        int pre=0, next=0;
        scanf("%d%d", &M, &pre);
        for(j=1;j<M;j++){
            scanf("%d", &next);
            G[pre].push_back(next);
            G[next].push_back(pre);
            Line[pre*10000+next] = i;         //将两个站台代码合并到一起，形成8位数 
            Line[next*10000+pre] = i;
            pre=next;
        }
    }
}

        解决了以上疑问之后，就是如何解决这个问题了，也就是采用什么核心算法

        这里我采用的是DFS算法，因为这里是单源无权图，所以Dijkstra和Floyd算法肯定不适用，但BFS算法自然也可以的。

//1131 Subway Map (30 分)
#include<stdio.h>
#include<vector>
#include<unordered_map>
using namespace std;

int N, K, Mintrans, Minsite;    //Mintrans为最小换乘数，Minsite为最小站点数 
unordered_map <int, vector <int> > G;         //这样就可以一个站台，多个邻接点了 ，这是矩阵、链表都不能做到的 
unordered_map<int, int> Line;

void CreatG_Line(void);
void DFS(unordered_map<int,bool> &visit, vector<int> &path, vector<int> &tpath, int start, int end, int site_Cnt);
int Transfer(vector<int> &tpath);

int main()
{
    scanf("%d", &N);
    CreatG_Line();
    
    scanf("%d", &K);
    for(int i=1;i<=K;i++){
        int start=0, end=0, site_Cnt=0;
        Mintrans = 10000;
         Minsite = 10000;
        scanf("%d%d", &start, &end);
        vector <int> path; //最终路径中所经过的站点，注意这里不能采用全局变量，因为每一轮循环是不同起点终点的，需要更新。 
        vector <int> tpath; //临时路径中所经过的站点 
        unordered_map<int,bool> visit;
        DFS(visit, path, tpath, start, end, site_Cnt);
        //输出
        int preline = Line[path[0]*10000+path[1]];
        int presite = start;
        int f=path.size();
        printf("%d\n", f-1);
        for(int j=2;j<f;j++){
            int nextline = Line[path[j-1]*10000+path[j]];
            if(preline!=nextline){
                printf("Take Line#%d from %04d to %04d.\n", preline, presite, path[j-1]);
                preline = nextline;
                presite = path[j-1];
            }
        } 
        if(preline == Line[path[f-2]*10000+path[f-1]]) 
        printf("Take Line#%d from %04d to %04d.\n", preline, presite, end);
    }
    
    return 0;
}

void CreatG_Line(void)
{
    int M=0, i=0, j=0;
    for(i=1;i<=N;i++){
        int pre=0, next=0;
        scanf("%d%d", &M, &pre);
        for(j=1;j<M;j++){
            scanf("%d", &next);
            G[pre].push_back(next);
            G[next].push_back(pre);
            Line[pre*10000+next] = i;         //将两个站台代码合并到一起，形成8位数 
            Line[next*10000+pre] = i;
            pre=next;
        }
    }
}

void DFS(unordered_map<int,bool> &visit, vector<int> &path, vector<int> &tpath, int start, int end, int site_Cnt)
{
    if(!visit[start]){
        visit[start] = true;
        tpath.push_back(start);
    }
    if(start == end){
        int TransNumber = Transfer(tpath);      //TransNumber为中转站个数 
        if(Minsite > site_Cnt || (Minsite==site_Cnt && Mintrans>TransNumber) ){
            Minsite = site_Cnt;
            Mintrans = TransNumber;
            path=tpath;
        }
        return;
    }
    for(int i=0;i<G[start].size();i++){
        if(!visit[G[start][i]]){
            DFS(visit,path,tpath,G[start][i],end,site_Cnt+1);
            visit[G[start][i]] = false;
            tpath.pop_back();
        } 
    }
    
}

int Transfer(vector<int> &tpath)
{
    int pre=0, next=0, i=0, TransNumber=0;
    pre = Line[tpath[0]*10000+tpath[1]];
     for(i=2;i<tpath.size();i++){
         next = Line[tpath[i-1]*10000+tpath[i]];
         if(pre!=next) TransNumber++;
         pre=next;
     }
     return TransNumber;
}