pat甲级（中等题）地铁地图（dijkstra应用）

acwing：1624. 地铁地图

在大城市，地铁系统对于游客来说总是看起来如此复杂。

为了使你对此有所了解，下图显示了北京地铁的地图。

现在，请你帮助编写一个程序，给定用户的起始位置，找到到达其目的地的最快方法。

输入格式

第一行包含一个正整数 N，表示地铁线路的数量。

接下来 N 行，第 i 行以下列格式描述第 i 条线路（地铁线路都是双向的）：

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

其中 M 是站点数量，S[i] 是沿线站点的编号（站点编号是从 0000 到 9999 的 4 位数字）。

确保这些站点是按照地铁行进顺序给出的，即地铁会从 S[i] 直接开到 S[i+1]。

注意，可能会存在回路，但不存在自环（即地铁从 S 出发，直接开向 S，中途不经过任何站点）。

每个车站间隔都只属于一条唯一线路。

一些线路可能会在某些站点（中转站）彼此交叉，但是不能有任何站点作为中转站时，有超过 5 条线路在该站点交汇。

描述完地铁线路信息后，包含一行整数 K，表示询问次数。

接下来 K 行，每行描述一个询问，包含两个站点编号分别表示始发站和目的地。

下面是示例图：

保证所有站点都能到达，询问站点编号合法。

输出格式

对于每个询问，首先输出最少需要停靠的站点数量，然后以如下格式输出最佳线路：

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

其中 Xi 是线路编号，Si 是站点编号，除始发站和终点站外，只输出中转站。

如果最快线路不唯一，则输出换乘次数最少的线路，保证唯一。

 思路：

这题难点在于建图，建图思路有两种。可以以1为边权，逐一建边，只有线路上相邻两边相邻。也可以以间隔长度为边权，按线路建边，让同一条线路上任意两站相邻。（这两种方法后者简单，前者较为复杂，我用的第一种）

代码：

#include<bits/stdc++.h>
using namespace std;
const int N = 100010, M = 1e6+10;
typedef pair<int, int>PII;
int g[110][110];
int h[N], e[M], w[M], ne[M], idx;
int dis[N], cnt[N];
int path[N], line[N];
bool st[N];
int n, m;
void add(int a, int b, int c) {
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
void dijk(int a)
{
    memset(st, false, sizeof(st));
    memset(cnt, 0, sizeof(cnt));
    memset(path, 0, sizeof(path));
    memset(line, 0, sizeof(line));
    memset(dis, 0x3f, sizeof(dis));
    priority_queue<PII, vector<PII>, greater<PII>> q;
    q.push({ 0,a });
    dis[a] = 0, cnt[a] = 1;
    while (q.size()) {
        auto t = q.top();
        q.pop();
        int v = t.second;
        if (st[v]) {
            continue;
        }
        st[v] = true;
        for (int i = h[v];i != -1;i = ne[i]) {
            int j = e[i];
            if (dis[j] > dis[v] + 1) {
                dis[j] = dis[v] + 1;
                cnt[j] = cnt[v];
                path[j] = path[v];
                line[j] = w[i];
                q.push({ dis[j],j });
                if (line[j] != line[v]) {
                    cnt[j] = cnt[v] + 1;
                    path[j] = v;
                }

            }
            else if (dis[j] == dis[v] + 1) {
                if (cnt[j] > cnt[v] + (line[v] == w[i] ? 0 : 1)) {
                    cnt[j] = cnt[v] + (line[v] == w[i] ? 0 : 1);
                    q.push({ dis[j],j });
                    path[j] = path[v];
                line[j] = w[i];
                if (line[j] != line[v]) {
                    path[j] = v;
                }
               }
                


            }
        }
    }
}
void solve()
{
    memset(h, -1, sizeof(h));
    cin >> n;
    for (int i = 1;i <= n;i++) {
        int x;
        cin >> x;
        for (int j = 1;j <= x;j++) {
            cin >> g[i][j];
        }
        for (int j = 2;j <= x;j++) {
            add(g[i][j - 1], g[i][j], i);
            add(g[i][j], g[i][j - 1], i);
        }

    }
    cin >> m;
    for (int j = 1;j <= m;j++) {
        int a, b;
        cin >> a >> b;
        dijk(a);
        int CNT = 0;
        int P[N];
        string s[N];
        for (int i = b;i != a;i = path[i]) {
            P[CNT++] = path[i];
            int std_ = 10000;
            s[CNT - 1].insert(0, "0000");
            for (int k = 0;k < 4;k++) {
                std_ /= 10;
                s[CNT - 1][k] = ((P[CNT - 1] / std_) - 10 * (P[CNT - 1] / (10 * std_))) + 48;
            }
        }
        string sen;
        int std__ = 10000;
        sen.insert(0, "0000");
        for (int k = 0;k < 4;k++) {
            std__ /= 10;
            sen[k] = ((b / std__) - 10 * (b / (10 * std__))) + 48;
        }
        printf("%d\n", dis[b]);
        for (int i = CNT - 1;i > 0;i--) {
            printf("Take Line#%d from %s to %s.\n", line[P[i - 1]], s[i].c_str(), s[i - 1].c_str());
        }
        printf("Take Line#%d from %s to %s.\n", line[b], s[0].c_str(), sen.c_str());
    }


}
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    int t = 1;
    while (t--) {
        solve();
    }
    return 0;
}