PAT【甲级】1111

原创 于 2021-04-28 17:34:46 发布 · 243 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

题目链接：PAT【甲级】1111
题目简述：给⼀张地图，两个结点中的道路，既有距离属性也有时间属性，要求根据地图推荐两条/一条路线：一条是快速到达路线，一条是短距离的路线。

超时的DFS版本代码【最后一个点超时】

#include<bits/stdc++.h>
using namespace std;

int source, dest, min_time = -1, min_distance = -1, min_intersections = -1, min_dtime = -1;
vector<int> vertexs[500], vis(500, 0), ans_t, ans_d, temp;
vector<vector<int>> times(500, vector<int>(500, -1)), distances(500, vector<int>(500, -1));

void dfs(int beg, int time, int distance, int intersections){
    if(beg == dest){
        //如果用时相等且站点数最小、用时更短、没有初始化（这里站点数和最小时间总是同时更改所以只需判断一个）
        //还有就是要千万注意逻辑短路这个现象，所以这边的条件判断还是要有顺序进行的
        if(min_time == -1 || time < min_time || (time == min_time && intersections < min_intersections)){
            min_intersections = intersections; 
            min_time = time;
            ans_t.clear();
            for (int i = 0; i < temp.size();i++)
                ans_t.push_back(temp[i]);
        }
        if(min_distance == -1 || distance < min_distance || (distance == min_distance && time < min_dtime)){
            min_dtime = time;
            min_distance = distance;
            ans_d.clear();
            for (int i = 0; i < temp.size();i++)
                ans_d.push_back(temp[i]);
        }
        return;
    }
    if((time > min_time && min_time != -1) && (distance > min_distance && min_distance != -1))
        return;//剪枝操作
    for (int i = 0; i < vertexs[beg].size();i++){
        if(vis[vertexs[beg][i]] == 0){
            vis[vertexs[beg][i]] = 1;
            temp.push_back(vertexs[beg][i]);
            dfs(vertexs[beg][i], times[vertexs[beg][i]][beg] + time, distances[vertexs[beg][i]][beg] + distance, intersections + 1);
            vis[vertexs[beg][i]] = 0;
            temp.pop_back();
        }
    }
}

int main(){
    int n, m, isSame = 1;
    int s, e, a, l, t;
    cin >> n >> m;
    for (int i = 0; i < m;i++){
        cin >> s >> e >> a >> l >> t;
        vertexs[s].push_back(e);
        vertexs[e].push_back(s);
        times[s][e] = times[e][s] = t;
        distances[s][e] = distances[e][s] = l;
    }
    cin >> source >> dest;
    vis[source] = 1;
    dfs(source, 0, 0, 0);
    if(ans_d.size() == ans_t.size()){
        for (int i = 0; i < ans_t.size();i++){
            if(ans_t[i] != ans_d[i]){
                isSame = 0;
                break;//能省点时间就省点
            }
        }
    }else
        isSame = 0;
    if(isSame == 0){
        printf("Distance = %d: %d", min_distance, source);
        for (int i = 0; i < ans_d.size();i++)
            printf(" -> %d", ans_d[i]);
        printf("\nTime = %d: %d", min_time, source);
        for (int i = 0; i < ans_t.size();i++)
            printf(" -> %d", ans_t[i]);
    }else{
        printf("Distance = %d; Time = %d: %d", min_distance, min_time, source);
        for (int i = 0; i < ans_t.size();i++)
            printf(" -> %d", ans_t[i]);
    }
    cout << endl;
    return 0;
}

哎，可惜超时了。本来以为这个图应该不是很复杂，边数不是很多的那种，没想到最后一个点超时了。

AC的代码

#include<bits/stdc++.h>
using namespace std;

int n, m, source, dest, min_distance, min_time;
vector<int> ans_t, ans_d, dpre(500, -1), tpre(500, -1);
vector<vector<int>> times(500, vector<int>(500, -1)), distances(500, vector<int>(500, -1)), graph(500,vector<int>(500, 0));
void dfs1(int x){
    if(x == -1) return;
    dfs1(dpre[x]);
    ans_d.push_back(x);
}
void dfs2(int x){
    if(x == -1) return;
    dfs2(tpre[x]);
    ans_t.push_back(x);
}
void dijkstra1(int beg){
    vector<int> lowcost(500, 0x3f3f3f3f), vis(500, 0), dtime(500, 0x3f3f3f3f);
    lowcost[beg] = 0;
    dpre[beg] = -1;
    for (int i = 0; i < n;i++){
        int Min = 0x3f3f3f3f, k = -1;
        for (int j = 0; j < n;j++){
            if(vis[j] == 0 && lowcost[j] < Min){
                Min = lowcost[j];
                k = j;
            }
        }
        if(k == -1) break;
        vis[k] = 1;
        for (int j = 0; j < n;j++){
            if(vis[j] == 0 && graph[j][k] == 1){
                //如果满足条件则更新信息，这里要注意逻辑短路现象
                if(lowcost[j] > lowcost[k] + distances[j][k] || (lowcost[j] == lowcost[k] + distances[j][k] && dtime[k] + times[k][j] < dtime[j])){
                    dpre[j] = k;
                    dtime[j] = dtime[k] + times[k][j];
                    lowcost[j] = lowcost[k] + distances[j][k];
                }
            }
        }
    }
    min_distance = lowcost[dest];
    dfs1(dest);
}

void dijkstra2(int beg){
    vector<int> lowcost(500, 0x3f3f3f3f), vis(500, 0), intersections(500, 0x3f3f3f3f);
    lowcost[beg] = 0;
    tpre[beg] = -1;
    for (int i = 0; i < n;i++){
        int Min = 0x3f3f3f3f, k = -1;
        for (int j = 0; j < n;j++){
            if(vis[j] == 0 && lowcost[j] < Min){
                Min = lowcost[j];
                k = j;
            }
        }
        if(k == -1) break;
        vis[k] = 1;
        for (int j = 0; j < n;j++){
            if(vis[j] == 0 && graph[j][k] == 1){
                if(lowcost[j] > lowcost[k] + times[j][k] || (lowcost[j] == lowcost[k] + times[j][k] && intersections[k] + 1 < intersections[j])){
                    tpre[j] = k;
                    intersections[j] = intersections[k] + 1;
                    lowcost[j] = lowcost[k] + times[j][k];
                }
            }
        }
    }
    min_time = lowcost[dest];
    dfs2(dest);
}

int main(){
    int s, e, a, l, t, isSame = 1;
    cin >> n >> m;
    for (int i = 0; i < m;i++){
        cin >> s >> e >> a >> l >> t;
        graph[s][e] = graph[e][s] = 1;
        times[s][e] = times[e][s] = t;
        distances[s][e] = distances[e][s] = l;
    }
    cin >> source >> dest;
    dijkstra1(source);
    dijkstra2(source);
    if(ans_d.size() == ans_t.size()){
        for (int i = 0; i < ans_t.size();i++){
            if(ans_t[i] != ans_d[i]){
                isSame = 0;
                break;//能省点时间就省点
            }
        }
    }else
        isSame = 0;
    if(isSame == 0){
        printf("Distance = %d: %d", min_distance, ans_d[0]);
        for (int i = 1; i < ans_d.size();i++)
            printf(" -> %d", ans_d[i]);
        printf("\nTime = %d: %d", min_time, ans_t[0]);
        for (int i = 1; i < ans_t.size();i++)
            printf(" -> %d", ans_t[i]);
    }else{
        printf("Distance = %d; Time = %d: %d", min_distance, min_time, ans_t[0]);
        for (int i = 1; i < ans_t.size();i++)
            printf(" -> %d", ans_t[i]);
    }
    cout << endl;
    return 0;
}

其实这些题目练习熟了还是比较简单的，无非就是这两种；不行就换着来。套着框架写就行了。

1111 对称日【PAT (Basic Level) Practice （中文）】
少侠PSY的博客
10-19 177
1111 对称日【PAT (Basic Level) Practice （中文）】
PAT甲级 1111 - Online Map（最短路）
weixin_30947043的博客
03-20 172
PAT甲级1111 题目链接 https://www.patest.cn/contests/pat-a-practise/1111 【题意】 输入当前的位置和目的地，在线地图可以推荐几条路径。现在你的任务是向用户推荐两条路径：一条最短，另一条最快，输入确保有解。 【输入格式】 单组输入，第一行分别给出两个正整数N（2 &lt...
PAT 1111
一介
08-01 1196
1111. Online Map (30) 时间限制 300 ms 内存限制 65536 kB 代码长度限制 16000 B 判题程序 Standard 作者 CHEN, Yue Input our current position and a destination, a
pat-1111
江船夜雨听笛的博客
01-20 170
必须二刷不废话 #include<iostream> #include<vector> #include<algorithm> using namespace std; vector<int> mindis,mint; int sr,fin,dispre[509],tpre[509]; int n,m,a[509][509],t[509][509],_1,_2,_3,_4,_5,visit[509]={0},dist1,t1,u,distsr[509],p
PAT（甲级）1111 Online Map (30point(s)) 最短路算法
hjyp的博客
06-29 222
题目 题目链接 思路 题目大意：给一张图，注意有的边是有向的，有的是无向的；分别找出从起点到终点最短路径和最快路径；如果两个路径相同，只输出一次； 首先来看题的要求，需要输出路径，那么需要用一个pre数组存储最终路径上每一个节点的前驱； 由于要求最短路和最快路，所以需要两次Dijktras算法：在求最短路的过程中，由于可能会出现最短路相同的情况，所以需要维护一个花费时间最短的t数组（注意：这个最短时间并不是全局最短时间，只是在满足最短路的前提下的最短时间，一会计算最短时间时需要重新赋值）； 接着再求一下最短
PAT：PAT甲级练习
02-25
PAT甲级练习通常指的是PAT的高级别考试，对于想要在IT行业中提升编程技能，尤其是准备参加相关专业比赛或求职的学员来说，具有很高的学习价值。 描述中提到的是个人进行PAT甲级练习的过程，包括了自己独立完成的...
pat甲级单词pat甲级单词pat甲级单词
06-12
### pat甲级单词知识点解析 #### 1. **逗号(Commas)** - **定义**: 逗号是一种标点符号，在编程语言中通常用于分割列表中的元素或参数。 - **用途**: 在C/C++等语言中，逗号用于数组初始化、函数参数列表等。 ####...
PAT甲级复习/CAIP复习
07-23
【标题】"PAT甲级复习/CAIP复习" 涉及的是计算机编程与算法相关的考试准备，特别是针对PAT（Programming Ability Test）甲级和CAIP（Computer Ability and Information Processing）的复习。PAT甲级是面向高校学生的...
PAT甲级1011题代码
12-25
PAT甲级第1011题，之前自己做的时候写的代码，正确通过，但是效率不保证
【C++】PAT甲级题目实现
01-07
为了记录我在准备PAT甲级的练习，特开此页。 在练习的过程中吸收了大量博主的经验，特别是大神柳婼:https://blog.csdn.net/liuchuo。 但是由于代码风格的不同，我在学习他们的想法的同时也在努力形成自己的C++代码...
PAT - 甲级 1111. Online Map (30)（Dijkstra+DFS）
i逆天耗子
11-01 436
Input our current position and a destination, an online map can recommend several paths. Now your job is to recommend two paths to your user: one is the shortest, and the other is the fastest. It is g
PAT日志 1111
doublefloatint的博客
03-03 191
顽强的小白 1111 Online Map （30 分） Input our current position and a destination, an online map can recommend several paths. Now your job is to recommend two paths to your user: one is the shortest, and the ...
*浙大PAT甲级 1111
威的博客
09-09 1128
通过两边的dij最短路算法。path[]数组记录最短路中每个结点的前驱结点，第一遍dij以路径的距离为主，如果相等则判断时间最短。第二遍dij以路径所花时间为主，如果相等则判断路径的结点数最小。如果两边dij算法的路径相同则合并在一起输出，否则分开输出。 AC代码： #include #include #include #include #include #include #include #
pat甲级1111
代洋
12-13 179
#include<stdio.h> #include<algorithm> #include<vector> using namespace std; const int N=510; const int INF=100000010; int n,m,st,ed; int G[N][N],cost[N][N]; int d[N],c[N]; bool vis[...
PAT甲级1111
weixin_42701161的博客
05-23 156
使用两次DIjikstra+dfs算法 #include <bits/stdc++.h> using namespace std; const int inf=99999; int e[510][510],w[510][510],dis[510],weight[510],nodeNum[510]; bool visit[510]; int n,m,c1,c2; vector<int> pre[510],pre2[510],dispath,timepath; void dfsdis
(PAT)1111. Online Map(迪杰斯特拉算法)
路漫漫 始于足下
02-28 1417
不用模板徒手码代码真TM刺激。。PAT，我有句MMP不知当讲不当讲。 迪杰斯特拉，一个非常不错的算法，老迪也是个牛人，哎呀，跑题了。。不懂DJ算法的话，参考：迪杰斯特拉算法 1111. Online Map (30) 时间限制 300 ms 内存限制 65536 kB 代码长度限制 16000 B 判
PAT甲级 1111. Online Map (30)
moffy_abo的博客
01-18 1320
Input our current position and a destination, an online map can recommend several paths. Now your job is to recommend two paths to your user: one is the shortest, and the other is the fastest. It is g...
pat1111-1120
basasuya的博客
06-14 386
1111 比较麻烦的最短路#include<cmath> #include<map> #include<iostream> #include<cstring> #include<cstdio> #include<set> #include<vector> #include<queue> #include<stack> #include<algorithm> using namespace std;
PAT甲级-1111- Online Map（Dijkstra算法+最短路径）
波点兔的博客
02-13 367
Input our current position and a destination, an online map can recommend several paths. Now your job is to recommend two paths to your user: one is the shortest, and the other is the fastest. It is g...
pat甲级 1024
最新发布
02-13
### 关于 PAT 甲级 1024 题目 PAT (Programming Ability Test) 是一项编程能力测试，其中甲级考试面向有一定编程基础的学生。对于 PAT 甲级 1024 题目，虽然具体题目描述未直接给出，但从相似类型的题目分析来看，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值