SDU_week7_B - TT 的旅行日记（前向星+双向dijkstra+堆优化）

题目描述

众所周知，TT 有一只魔法猫。

今天他在 B 站上开启了一次旅行直播，记录他与魔法猫在喵星旅游时的奇遇。 TT 从家里出发，准备乘坐猫猫快线前往喵星机场。猫猫快线分为经济线和商业线两种，它们的速度与价钱都不同。当然啦，商业线要比经济线贵，TT 平常只能坐经济线，但是今天 TT 的魔法猫变出了一张商业线车票，可以坐一站商业线。假设 TT 换乘的时间忽略不计，请你帮 TT 找到一条去喵星机场最快的线路，不然就要误机了！

输入
输入包含多组数据。每组数据第一行为 3 个整数 N, S 和 E (2 ≤ N ≤ 500, 1 ≤ S, E ≤ 100)，即猫猫快线中的车站总数，起点和终点（即喵星机场所在站）编号。

下一行包含一个整数 M (1 ≤ M ≤ 1000)，即经济线的路段条数。

接下来有 M 行，每行 3 个整数 X, Y, Z (1 ≤ X, Y ≤ N, 1 ≤ Z ≤ 100)，表示 TT 可以乘坐经济线在车站 X 和车站 Y 之间往返，其中单程需要 Z 分钟。

下一行为商业线的路段条数 K (1 ≤ K ≤ 1000)。

接下来 K 行是商业线路段的描述，格式同经济线。

所有路段都是双向的，但有可能必须使用商业车票才能到达机场。保证最优解唯一。

输出
对于每组数据，输出3行。第一行按访问顺序给出 TT 经过的各个车站（包括起点和终点），第二行是 TT 换乘商业线的车站编号（如果没有使用商业线车票，输出"Ticket Not Used"，不含引号），第三行是 TT 前往喵星机场花费的总时间。

本题不忽略多余的空格和制表符，且每一组答案间要输出一个换行

输入样例
4 1 4
4
1 2 2
1 3 3
2 4 4
3 4 5
1
2 4 3

输出样例
1 2 4
2
5

题目分析

这道题是说给定图中起点终点，求一条路cost最小，最多使用一次快速线。
解决方法是从起点跑一次dijkstra，再从终点跑一次dijkstra，dijkstra的函数内还要记录每个节点的parent值（在松弛成功时），此时我们获得了任意一点距两个端点的最短路以及对应的路径：

int vis[maxn];
//priority_queue<pair<int, int>> q;//（dis，point）
void dijkstra(int S, int * dis,int * parent)
{
    //while (!q.empty())q.pop();
    memset(vis, 0, sizeof(vis));
    priority_queue<pair<int, int>> q;//（dis，point）  在函数内申请容器会re？貌似不会
    dis[S] = 0;
    parent[S] = S;
    q.push(make_pair(0, S));
    while (!q.empty())
    {
        int x = q.top().second;
        q.pop();
        if (vis[x])continue;
        vis[x] = 1;
        for (int i = head[x]; i ; i=e[i].next)
        {
            int y = e[i].v;
            int W = e[i].w;
            if (dis[y] > dis[x] + W)
            {
                dis[y] = dis[x] + W;
                parent[y] = x;
                q.push(make_pair(-dis[y], y));//因为是大根堆，所以加负号变小根堆
            }
        }
    }
}

然后枚举商业线，但是要注意，有两种可能，即S-U-V-E或S-V-U-E，每次用cost记录最小值，以及UV端点是谁：

        cin >> K;
        for (int i = 1; i <= K; i++)
        {
            cin >> u >> v >> w;
            int temp = min(disS[u] + disE[v] + w, disS[v] + disE[u] + w);
            if (temp == disS[v] + disE[u] + w) swap(u, v);
            if (temp < cost)
            {
                cost = temp;
                ansU = u;
                ansV = v;
            }
        }

最后按照是否走商业线分两种情况输出即可。

长长记性

1. priority_queue默认大根堆，变为小根堆要么插入负值，要么重载结构体中‘<’号。
2. 这题在我一气呵成准备做下一题时候，RE了。于是各种测试，用到的极端数据没问题。注释法缩短RE范围，然而这并不科学（即通过注释判断哪里RE变为WA），最后发现是memset出了问题！
   填充字符用0x3f不要用127！！！
   填充字符用0x3f不要用127！！！
   填充字符用0x3f不要用127！！！
   127+127会溢出！比如S->U不连通，V->E不连通，那么下面比较的地方相加会溢出！！！
   正数用0x3f，负数用0xcf！！！

墨迹一句

可以考虑不使用pair(int,int)而自定义结构体，然后在vis数组的地方修改为：if(dis[u]<cur.dis) continue;
有什么好处呢？求最远路的时候，可以修改几个地方：重载<、初始化负无穷、两个小于号变大于号，即可

代码

#define _CRT_SECURE_NO_WARNINGS
#define _ ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

#include <bits/stdc++.h>
//#include <iostream>
//#include<algorithm>

using namespace std;
const int maxn = 999999;

int N, S, E,cost;//N个点 S起点 E终点，总时间
int road[maxn];//路线
int M, K, u, v, w;//M经济线 ，K商业线
int ansU, ansV;//商业线的两端点
int disS[maxn];//从S开始dijkstra
int disE[maxn];//从E开始dijkstra
int parentS[maxn];//父节点
int parentE[maxn];//父节点
struct edge
{
    int u, v, w, next;
}e[maxn];
int tot;//边数
int head[maxn];
void addEdge(int u,int v,int w)
{
    e[++tot].u = u;
    e[tot].v = v;
    e[tot].w = w;
    e[tot].next = head[u];
    head[u] = tot;
}

int vis[maxn];
//priority_queue<pair<int, int>> q;//（dis，point）
void dijkstra(int S, int * dis,int * parent)
{
    //while (!q.empty())q.pop();
    memset(vis, 0, sizeof(vis));
    priority_queue<pair<int, int>> q;//（dis，point）  在函数内申请容器会re？貌似不会
    dis[S] = 0;
    parent[S] = S;
    q.push(make_pair(0, S));
    while (!q.empty())
    {
        int x = q.top().second;
        q.pop();
        if (vis[x])continue;
        vis[x] = 1;
        for (int i = head[x]; i ; i=e[i].next)
        {
            int y = e[i].v;
            int W = e[i].w;
            if (dis[y] > dis[x] + W)
            {
                dis[y] = dis[x] + W;
                parent[y] = x;
                q.push(make_pair(-dis[y], y));//因为是大根堆，所以加负号变小根堆
            }
        }
    }
}

int main()
{
    int end_ = 0;
    while (cin >> N >> S >> E)
    {
        if (end_ != 0)cout << endl;//格式控制
        end_++;
        memset(e, 0, sizeof(e));
        memset(head, 0, sizeof(head));
        //填充字符用0x3f不要用127！！！
        //127+127会溢出！比如S->U不连通，V->E不连通，那么下面比较的地方相加会溢出！！！
        //正数用0x3f，负数用0xcf
        memset(disS, 0x3f, sizeof(disS));
        memset(disE, 0x3f, sizeof(disE));
        memset(parentS, 0, sizeof(parentS));
        memset(parentE, 0, sizeof(parentE));

        tot = 0;
        cin >> M;
        for (int i = 1; i <= M; i++)
        {
            cin >> u >> v >> w;
            addEdge(u, v, w);
            addEdge(v, u, w);
        }
        dijkstra(S,disS,parentS);
        dijkstra(E,disE,parentE);
        cost = disS[E];
        //if (cost > 99999)
        //{//不连通
        //    cout << S << 0 << 0 << E << endl;
        //    cout << 0 << endl;
        //    cout << 0x3f3f3f3f << endl;
        //}

        cin >> K;
        for (int i = 1; i <= K; i++)
        {
            cin >> u >> v >> w;
            int temp = min(disS[u] + disE[v] + w, disS[v] + disE[u] + w);
            if (temp == disS[v] + disE[u] + w) swap(u, v);
            if (temp < cost)
            {
                cost = temp;
                ansU = u;
                ansV = v;
            }
        }
        if (cost == disS[E])//不走商业线
        {
            int temp = E;
            int num = 0;
            while (temp != S)
            {
                road[++num] = temp;
                temp = parentS[temp];
            }
            cout << S;
            for (int i = num; i >= 1; i--)cout << ' ' << road[i];
            cout << endl;
            cout << "Ticket Not Used" << endl << cost << endl;
            continue;
        }

        //走商业线
        int temp = ansV;
        int num = 0;
        while (temp != E)
        {
            road[++num] = temp;
            temp = parentE[temp];
        }
        road[++num] = E;
        temp = ansU;
        while (temp != S)
        {
            road[++num] = temp;
            temp = parentS[temp];
        }
        //此时路径存储顺序为v...E,u...S+1
        cout << S;
        while (road[num] != E)
        {
            cout << ' ' << road[num];
            num--;
        }
        for (int i = 1; i <= num; i++)cout << ' ' << road[i];
        cout << endl;
        cout << ansU << endl << cost << endl;
    }
    return 0;
}