week7_B TT的旅行日记

最新推荐文章于 2024-12-11 23:31:34 发布

原创最新推荐文章于 2024-12-11 23:31:34 发布 · 166 阅读

0 ·

CC 4.0 BY-SA版权

TT带着魔法猫踏上喵星之旅，面对经济线与商业线的抉择，如何利用一张宝贵的商业线车票，找到最快路线，避免误机？本篇通过Dijkstra算法，解析最优路径寻找方法。

题目描述

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

输入输出

Input

输入包含多组数据。每组数据第一行为 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 行是商业线路段的描述，格式同经济线。
所有路段都是双向的，但有可能必须使用商业车票才能到达机场。保证最优解唯一。

Output

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

Sample Input

Sample Output

思路分析

题目给定了起点和终点，且边权非负，因此可用Dijkstra解决。
关键：松弛操作。将已松弛的点放入最小堆中，每次从最小堆中取出距离最短的点，一旦取出，该点的距离达到最小。
因为题目要求商业线最多乘坐一次，可以枚举每一条商业线，计算起点到u的最短路以及v到终点的最短路，加上该商业线所花费的时间。最后，再与不走商业线的答案取min。

注意

1.无向图中边添加两遍
2.最大堆丢负数变为最小堆

代码

#include<iostream>
#include<queue>
#include<string.h>
#include<vector>
using namespace std;

const int maxn=2005;
const int inf=1e9;
int vis[maxn],head[maxn],sta1[maxn],sta2[maxn];
int pre1[maxn],pre2[maxn],dis1[maxn],dis2[maxn];
//pre1[]和pre2[]分别用来存储以起点和终点为源点的最短路的路径
struct Edge{
    int to,w,nxt;
}edge[maxn];

int n,s,e,m,k,tot,ans=inf;
priority_queue<pair<int,int> > q;
vector<int> sta;

void dijkstra(int s,int *dis,int *pre)
{
    while(!q.empty()) q.pop();
    for(int i=0;i<=n;i++) 
    {
        dis[i]=inf;
        vis[i]=0;
    }
    q.push(make_pair(0,s));
    dis[s]=0;
    while(!q.empty())
    {
        int x=q.top().second;
        q.pop();
        if(vis[x]) continue;
        vis[x]=1;
        for(int i=head[x];i;i=edge[i].nxt)
        {
            int y=edge[i].to,
                w=edge[i].w;
            if(dis[y]>dis[x]+w)
            {//松弛操作
                dis[y]=dis[x]+w;
                pre[y]=x;//记录前一个点
                q.push(make_pair(-dis[y],y));
            }
        }
    }
}
void addEdge(int x,int y,int z)
{
    edge[++tot].to=y;
    edge[tot].w=z;
    edge[tot].nxt=head[x]; 
    head[x]=tot;
}
void init()
{//初始化
    tot=0;
    ans=inf;
    for(int i=0;i<=n;i++)
        head[i]=-1;
//  memset(sta,0,sizeof(sta));
    sta.clear();
    memset(pre1,0,sizeof(pre1));
    memset(pre2,0,sizeof(pre2));
}
int main()
{
    int flag=1;
    while(cin>>n>>s>>e)
    {
        if(flag!=1) cout<<endl;
        flag++;
        init();
        cin>>m;
        for(int i=0;i<m;i++)
        {
            int x,y,z; 
            cin>>x>>y>>z;
            addEdge(x,y,z);
            addEdge(y,x,z);//无向图边加两遍 
        }
        //跑两遍最短路，分别是起点为源点的最短路和终点为源点的最短路
        dijkstra(s,dis1,pre1);
        dijkstra(e,dis2,pre2);
        int tmp_x,tmp_y;
        cin>>k;
        for(int i=0;i<k;i++)
        {
            int x,y,z;
            cin>>x>>y>>z;
//ans=min(dis1[x]+dis2[y]+z,dis1[y]+dis2[x]+z);
//商业线的两端点分别为x,y，以下两种情况，源点到x和终点到y以及源点到y和终点到x
            if(ans>dis1[x]+dis2[y]+z)
            {
                ans=dis1[x]+dis2[y]+z;
                tmp_x=x;
                tmp_y=y;
            }
            if(ans>dis1[y]+dis2[x]+z)
            {
                ans=dis1[y]+dis2[x]+z;
                tmp_x=y;
                tmp_y=x;
            }
        }
        //与不走商业线比较
        if(ans>dis1[e])
        {//不走商业线耗时短
            int index=0;
            for(int i=e;i!=s;i=pre1[i])
                sta1[index++]=i;
            sta1[index]=s;
            for(int i=index;i>0;i--)
                cout<<sta1[i]<<" ";
            cout<<sta1[0]<<endl;
            cout<<"Ticket Not Used"<<endl;
            cout<<dis1[e]<<endl;
        }
        else{//走商业线耗时短
            for(int i=tmp_x;i!=s;i=pre1[i])
                sta.push_back(i);
            sta.push_back(s);
            for(int i=tmp_y;i!=e;i=pre2[i])
                sta.insert(sta.begin(),i);
            sta.insert(sta.begin(),e);
            //数组中路径存为：终点到起点，输出时应逆序输出
            for(int i=sta.size()-1;i>0;i--)
                cout<<sta[i]<<" ";
            cout<<sta[0]<<endl;
            cout<<tmp_x<<endl;
            cout<<ans<<endl;
        }
    }
    return 0;
}