PAT甲级刷题记录（1021-1030）

最新推荐文章于 2022-11-08 00:09:02 发布
最新推荐文章于 2022-11-08 00:09:02 发布
阅读量147 收藏
点赞数
分类专栏： PAT 文章标签： c++ 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45848585/article/details/127066939
版权

1021-1030

1021 Deepest Root(25)

#include<iostream>
#include<vector>
#include<cstring>
using namespace std;

const int maxn = 10001;
vector<int> adj[maxn];
bool visted[maxn] = {false};
int deep[maxn];
int max_ans = 0;
int cnt = 0;

void dfs(int u){
    for(int i = 0; i < adj[u].size();i++){
        if(visted[adj[u][i]]){
            continue;
        }else{
            visted[adj[u][i]] = true;
            dfs(adj[u][i]);
        }
    }
}

void dfs_for_deep(int u, int d, int root){
    if(!visted[u]){
        visted[u] = true;
        for(int i = 0; i < adj[u].size(); i++){
            if(!visted[adj[u][i]]){
                deep[root] = max(deep[root], d + 1);
                max_ans = max(max_ans, deep[root]);
                dfs_for_deep(adj[u][i], d + 1, root);
            }
        }
    }
}
int main(){
    int n;
    cin >> n;
    if(n == 1){
        cout << 1;
        return 0;
    }
    for(int i = 0; i < n; i++){
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    for(int i = 1; i <= n; i++){
        if(visted[i]){
            continue;
        }
        dfs(i);
        cnt++;
    }
    if(cnt >= 2){
        cout << "Error: " << cnt << " components";
        return 0;
    }
    for(int i = 1; i <= n ;i++){
        deep[i] = 1;
    }
    for(int i = 1; i <= n ;i++){
        memset(visted, false, sizeof(visted));
        dfs_for_deep(i, 1, i);
    }
    for(int i = 1; i <= n; i++){
        if(deep[i] == max_ans){
            cout << i << endl;
        }
    }
    
    return 0;
}

1022 Digital Library(30)

#include<iostream>
#include<vector>
#include<string>
#include<map>
#include<algorithm>
using namespace std;
map<string, vector<string> > m[6];

int main(){
    int n, k;
    string id, title, author, keywords, publisher, year;
    cin >> n;
    getchar();//吸收换行符
    for(int i = 0; i < n; i++){
        getline(cin, id);
        getline(cin, title);
        getline(cin, author);
        m[1][title].push_back(id);
        m[2][author].push_back(id);
        // keywords要区别对待
//         getline(cin, keywords);
        while(cin >> keywords){
            m[3][keywords].push_back(id);
            char c = getchar();
            if(c == '\n') break;
        }
        getline(cin, publisher);
        getline(cin, year);
        m[4][publisher].push_back(id);
        m[5][year].push_back(id);
    }
    cin >> k;
    int type;
    for(int i = 0; i < k; i++){
        scanf("%d: ", &type);
        string temp;
        getline(cin, temp);
        cout << type << ": " << temp<< endl;
        if(m[type][temp].size() == 0){
            cout << "Not Found" << endl;
            continue;
        }else{
            sort(m[type][temp].begin(), m[type][temp].end());
            for(int j = 0; j < m[type][temp].size(); j++){
                cout << m[type][temp][j] << endl;
            } 
        }
    }
    return 0;
}

1023 Have Fun with Numbers(20)

dict(num) ?= dict(num * 2)

原本用两个字典存储*2前后的变化，其实没必要，因为如果相等全是0

#include<string>
#include<iostream>
using namespace std;
int ans[22] = {0};
int dict[10] = {0};
int main(){
    string input;
    cin >> input;
    int ans_len = 1;
    for(int i = input.length() - 1; i >= 0; i--){
        //set dict1
        int temp = input[i] - '0';
        dict[temp]++;
        
        temp *= 2;
        ans[ans_len] += temp;
        //进位
        int t = ans[ans_len];
        ans[ans_len] = t % 10;
        ans[ans_len + 1] += t / 10;
        
        ans_len++;
        
        dict[t % 10]--;
    }
    bool flag = true;
    for(int i = 1; i <= 9; i++){
        if(dict[i] != 0){
            flag = false;
        }
    }
    flag == true ? printf("Yes\n") : printf("No\n");
    for(int i = ans_len; i >= 1; i--){
        if(i == ans_len && ans[i] == 0){
            continue;
        }
        printf("%d",ans[i]);
    }
}

1024 Palindromic Number(25)

isPalindromic((n + reverse(n))

可以用string自带的reverse函数来实现翻转

#include<cstdio>
#include<iostream>
#include<string>
using namespace std;
int num[100], len = 0;
int temp[100];
bool judge(){
    for(int i = 1; i <= len / 2; i++){
        if(num[i] != num[len - i + 1]){
            return false;
        }
    }
    return true;
}
int main(){
    string n;
    int k;
    cin >> n >> k;
    int step = 0;
    for(int i = n.length() - 1; i >= 0; i--){
        num[++len] = n[i] - '0';
    }
    if(judge()){
        for(int i = len; i >= 1; i--){
            cout << num[i];
        }
        cout << endl << step; 
        return 0;
    }
    while(step < k){
        step++;
        //reverse
        for(int i = 1; i <= len; i++){
            temp[i] = num[len - i + 1];
        }
        //add
        int carry = 0;
        for(int i = 1; i <= len; i++){
            num[i] = temp[i] + num[i] + carry;
            carry = 0;
            if(num[i] > 9){
                num[i] -= 10;
                carry = 1;
            }
        }
        if(carry == 1){
            num[++len] = carry;
        }
        if(judge()){
            break;
        }
    }
    for(int i = len; i >= 1; i--){
        cout << num[i];
    }
    cout << endl << step;
    return 0;
}

1025 PAT Ranking(25)

排序时注意多个条件，如分数相同时序号小的在前；rank会存在相同的。

#include<iostream>
#include<algorithm>
using namespace std;
struct User{
    string id;
    int score;
    int final_rank, local_rank;
    int location_number;
}user[30001];
bool cmp(User u1, User u2){
    //return u1.score > u2.score;
    return u1.score == u2.score ? u1.id < u2.id : u1.score > u2.score;
}
int main(){
    int n, k;
    int user_num = 0;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++){
        scanf("%d", &k);
        for(int j = 1; j <= k; j++){
            cin >> user[user_num + j].id >> user[user_num + j].score;
            user[user_num + j].location_number = i;
        }
        sort(user + user_num + 1, user + user_num + k + 1,cmp);
        
        user[user_num + 1].local_rank = 1;
        for(int j = 2; j <= k; j++){
            if(user[user_num + j].score == user[user_num + j - 1].score){
                user[user_num + j].local_rank = user[user_num + j - 1].local_rank;
            }else{
                user[user_num + j].local_rank = j;
            }
        }
        user_num += k;
    }
    
    sort(user + 1, user + user_num + 1, cmp);
    user[1].final_rank = 1;
    for(int i = 2; i <= user_num; i++){
        if(user[i].score == user[i - 1].score){
            user[i].final_rank = user[i - 1].final_rank;
        }else{
            user[i].final_rank = i;
        }
    }
    cout << user_num << endl;
    for(int i = 1; i <= user_num; i++){ 
        cout << user[i].id << " " << user[i].final_rank << " "
             << user[i].location_number << " " << user[i].local_rank
             << endl;
    }
}

1026 Table Tennis(30)

#include<iostream>
#include<queue>
#include<map>
using namespace std;
const int maxT = 100000;//最大时间 以秒为单位
const int maxn = 10001;//最大测试样例数

int table, vtable;//记录空闲的普通桌子和vip桌子
int now, nowt;//记录当前时间和当前时间使用的桌子编号

//T和V分别存储t时刻到达用户的play time和vip状态
int T[maxT], V[maxT]; 

int vip[maxn];//存储桌子的vip状态
int AnsI[maxn], AnsO[maxn], num[maxn];//存储最后结果

map<int, int> Table;//记录Table i对应的剩余使用时间
queue<int> Wait, vWait;//分别存储普通用户和vip用户的到达时间
int main(){
    int cnt = 0;
    
    int n, m, k;
    cin >> n;
    for(int i = 0; i < n; i++){
        int H, M, S;
        scanf("%d:%d:%d", &H, &M, &S);
        int t = H * 3600 + M * 60 + S;
        scanf("%d %d", &T[t], &V[t]);
        T[t] = min(T[t], 120) * 60;
    }
    cin >> m >> k;
    for(int i = 0; i < k; i++){
        int temp;
        cin >> temp;
        vip[temp] = 1;
    }
    //模拟每一秒
    for(int Time = 28800; Time < 75600; Time++){
        now = 0, table = 0, vtable = 0;
        //Time时刻有vip用户进入
        if(T[Time] && V[Time]){
            vWait.push(Time);
        }else if(T[Time]){
           //普通用户
            Wait.push(Time);
        }
        
        for(int i = 1; i <= m; i++){
            if(Table[i] > 0) Table[i]--;
            if(Table[i] == 0 && vip[i] && vtable == 0){
                vtable = i;
            }
            if(Table[i] == 0 && table ==0){
                table = i;
            }
        }
        
        if(!vWait.empty() && (table || vtable)){
            now = vWait.front();
            if(vtable != 0){
                nowt = vtable;
                vWait.pop();
            }else{
                nowt = table;
                if(!Wait.empty() && Wait.front() < vWait.front()){
                    now = Wait.front();
                    Wait.pop();
                }else{
                    vWait.pop();
                }
            }
        }else if(!Wait.empty() && (table || vtable)){
            if(table != 0){
                nowt = table;
            }else{
                nowt = vtable;
            }
            now = Wait.front();
            Wait.pop();
        }
        
        if(now == 0){
            continue;
        }
        Table[nowt] = T[now];
        AnsI[cnt] = now;
        AnsO[cnt] = Time;
        cnt++;
        num[nowt]++;
    }
    for(int i = 0; i < cnt; i++){
        //这里加30s后转化为分钟级
        printf("%02d:%02d:%02d %02d:%02d:%02d %d\n",
              AnsI[i] / 3600, AnsI[i] % 3600 / 60, AnsI[i] % 60,
              AnsO[i] / 3600, AnsO[i] % 3600 / 60, AnsO[i] % 60,
              (AnsO[i] - AnsI[i] + 30) / 60);
    }
    for(int i = 1; i <= m; i++){
        if(i != 1) cout << " ";
        cout << num[i];
    }
    
    return 0;
}

1027 Colors in Mars(20)

#include<cstdio>
using namespace std;
char ans[14] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C'};
int main(){
    printf("#");
    int n;
    for(int i = 1; i <= 3; i++){
        scanf("%d", &n);
        printf("%c%c", ans[n / 13], ans[n % 13]);
    }
    
}

1028 List Sorting(25)

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
struct student{
    int id;
    string name;
    int score;
}stu[100001];
int n, c;
bool cmp(student s1, student s2){
    if(c == 1){
        return s1.id < s2.id;
    }else if(c == 2){
        if(s1.name == s2.name){
            return s1.id < s2.id;
        }
        return s1.name < s2.name;
    }else{
        if(s1.score == s2.score){
            return s1.id < s2.id;
        }
        return s1.score < s2.score;
    }
}
int main(){
    scanf("%d%d", &n, &c);
    for(int i = 0; i < n; i++){
        cin >> stu[i].id >> stu[i].name >> stu[i].score;
    }
    
    sort(stu, stu + n, cmp);
    for(int i = 0; i < n; i++){
        printf("%06d ",stu[i].id);
        cout << stu[i].name << " " << stu[i].score << endl;
    }
}

1029 Median(25)

#include<iostream>
#include<set>
using namespace std;

set<int> s;
int main(){
    int n, k;
    for(int i = 0; i < 2; i++){
        scanf("%d", &n);
        for(int i = 0; i < n; i++){
            scanf("%d", &k);
            s.insert(k);
        }
    }
    set<int>::iterator i;
    int cnt = (s.size() - 1) / 2;
    for(i = s.begin(); i != s.end(); i++){
        if(cnt == 0){
            cout << *i;
        }
        cnt--;
    }
}

1030 Travel Plan(30)

#include<iostream>
#include<vector>
using namespace std;
const int INF = 1e9;
const int maxn = 501;
int adj[maxn][maxn], cost[maxn][maxn], dis[maxn];
bool visited[maxn] = {false};
vector<int> path, temppath;
vector<int> pre[maxn];

int mincost = INF;

int n, m, s, d;
void dfs(int v){
    temppath.push_back(v);
    if(v == s){
        int tempcost = 0;
        for(int i = temppath.size() - 1; i > 0; i--){
            tempcost += cost[temppath[i]][temppath[i - 1]];
        }
        if(tempcost < mincost){
            mincost = tempcost;
            path = temppath;
        }
        temppath.pop_back();
        return;
    }
    for(int i = 0; i < pre[v].size(); i++){
        dfs(pre[v][i]);
    }
    temppath.pop_back();
}


int main(){
    fill(adj[0], adj[0] + maxn * maxn, INF);
    fill(dis, dis + maxn, INF);
    
    cin >> n >> m >> s >> d;
    for(int i = 0; i < m; i++){
        int c1, c2, distance, c;
        cin >> c1 >> c2 >> distance >> c;
        adj[c1][c2] = adj[c2][c1]= distance;
        cost[c1][c2] = cost[c2][c1] = c;
    }
    //这里注意是s 开始写0能通过测试样例但是通不过其它
    dis[s] = 0;
    for(int i = 0; i < n; i++){
        int u = -1, minn = INF;
        for(int v = 0; v < n; v++){
            if(!visited[v] && dis[v] < minn){
                minn = dis[v];
                u = v;
            }
        }
        if(u == -1){
            break;
        }
        visited[u] = true;
        for(int v = 0; v < n; v++){
//             if(!visited[v] && dis[u] + adj[u][v] < dis[v]){
//                 dis[v] = dis[u] + adj[u][v];
//                 pre[v].clear();
//                 pre[v].push_back(u);
//             }else if(!visited[v] && dis[v] == dis[u] + adj[u][v]){
//                 pre[v].push_back(u);
//             }
            if(!visited[v] && adj[u][v] != INF){
                if(dis[v] > dis[u] + adj[u][v]){
                    dis[v] = dis[u] + adj[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                }else if(dis[v] == dis[u] + adj[u][v]){
                    pre[v].push_back(u);
                }
            }
        }
    }
    dfs(d);
    for(int i = path.size() - 1; i >= 0; i--){
        printf("%d ", path[i]);
    }
    printf("%d %d", dis[d], mincost);
    return 0;
}
4399彪哥
关注
专栏目录
2020年7月25日春季PAT甲级满分记录
神秘的义勇神驹的博客
07-30 889
emmmmm其实我就是个弱鸡，3月份的时候刷题准备来着，然后一直玩到保研夏令营，真是太作死了....... 现在想想都不知道能不能过浙大计算机的初审，o(╥﹏╥)o 下面写的主要是思路和考试的心理历程： 第一题： 直接判断素数 每次用string的erase(s.begin()) 再stoi(s)即可 一开始还写的打表然后内存超限了- - 太久没写了 这题考试时正确率应该有个50% 第三题： 没错弄完第一题，我看了下正确率，虽然此时提交数还很少，但果断做第三题 （一般前两题有点小坑，按以往
PAT-B-1030
aoqieshai7178的博客
08-24 186
1030完美数列（25分） 给定一个正整数数列，和正整数p，设这个数列中的最大值是M，最小值是m，如果M≤mp，则称这个数列是完美数列。 现在给定参数p和一些正整数，请你从中选择尽可能多的数构成一个完美数列。 输入格式： 输入第一行给出两个正整数N和p，其中N（≤10​5​​）是输入的正整数的个数，p（≤10​9​​）是给定的参数。第二行给出...
PAT（甲级）1030 Travel Plan (30point(s))
hjyp的博客
05-31 203
题目 题目链接 思路 题目大意: 在保证距离最短的情况下使其花费尽可能小； 可以用Dijktras + DFS做，也可以直接用Dijktras算法做，前者根据第一标尺距离最短把每个节点的前驱全部存储下来，然后用DFS选一条花费最小的；后者只存储每个元素的一个前驱，所以在第一标尺距离相等的情况下，需要判断第二标尺花费是不是会进行优化，进而修改前驱节点； 代码 #include<iostream> #include<vector> #include<cstring> #inc
PAT甲级刷题记录——1030 Travel Plan (30分)
一只奋斗中的本科生
04-21 431
A traveler’s map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to decide the shortest path b...
PAT甲级（1016-1030）
qq_51776588的博客
09-09 584
题目列表 知识点 1016 Phone Bills (25 分) 结构体排序（分段处理），时间计算 1017 Queueing at Bank (25 分) 结构体排序，模拟 1018 Public Bike Management (30 分) dij最短路，记录路径，dfs遍历最短路 1019 General Palindromic Number (20 分) 回文数判断，数组存储(不能用字符串) 1020 Tree Traversals (25 分) 后序+中序=>...
A1030 Travel Plan（30分）PAT 甲级(Advanced Level) Practice（C++）满分题解【Dijkstra+DFS]
qq_47677800的博客
07-29 497
采用了Dijkstra算法和深度优先遍历DFS，用root数组存放从设定的起始点到每个点i的最短路径。题目要求是首先找到最短路径，如果最短路径的解不止一个，就再找到花费代价最小的。
PAT甲级刷题笔记
genwin_T的博客
08-26 552
PAT甲级刷题笔记一些自带函数的用法memset 一些自带函数的用法 memset 头文件：cstring int a[10]; memset(a,1,sizeof(a)); //将数组a内的元素初值设置为1
柳婼-PAT&蓝桥杯&LeetCode的学习路径&刷题经验1
08-03
从0基础到PAT甲级100分的高效学习路径及书籍推荐 对于0基础的学生，可以从以下步骤开始： 1. 学习基础编程知识，例如《C Primer Plus》、《Java核心技术卷I》。 2. 学习数据结构和算法，如《算法导论》、《数据...
程序员刷题judge-PAT_Solutions::lollipop:MyPAT(AdvancedLevel)练习解决方案
07-07
刷题 judge My PAT Solutions 记录我在刷 PAT 甲级时遇到的一些问题以及总结的经验。做法可能不是最优的，如有更好的解法，欢迎 PR！ 1001 A+B Format（20 分） 1002 A+B for Polynomials（25 分） 解题思路 对于 ...
Algorithm:个人刷题记录，译文来自蓝桥杯，PAT，力扣
03-29
只更新了PAT甲级题，部分解题代码全上传上来了在答案文件夹下，译文在浙大PAT练习网站中都有，但记笔记的时候还是都被捏了下来，所以和思路也一并放在一个另一个文件夹中，解题笔记按分类写的，但也是只有一部分，...
PAT甲级-1030 Travel Plan (30分)
卷子的博客
04-09 251
点击链接PAT甲级-AC全解汇总 题目： A traveler’s map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to decid...
pat甲级1030 dijkstra算法，多标准的两种处理方法
sinat_37517996的博客
02-24 273
1、dijkstra 同时处理多个标准。 #include <cstdio> #include <climits> #include <algorithm> #include <stack> using namespace std; struct edge{ int dis, price; edge(){ dis ...
PAT 甲级 1030 （Travel Plan）
qq_42865772的博客
09-15 207
PAT 甲级 1030题目要求翻译代码思路 题目要求 A traveler’s map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to decide the shortest path between his/her starting city
【PAT（甲级）】1030 Travel Plan
weixin_55202895的博客
08-12 325
【PAT（甲级）】1030 Travel Plan（Dijkstra+dfs）
PAT（甲级）1021笔记
qq_41819953的博客
07-14 330
1021 ♥-recordPAT（甲级）1021笔记-161、原题参照PAT官网2、生词3、知识点4、代码record PAT（甲级）1021笔记-16 1、原题参照PAT官网 2、生词 3、知识点 set集合是c++ stl库中自带的一个容器，set具有以下两个特点： 1 set中的元素都是排好序的 2 set集合中没有重复的元素 set、vector、iterator知识，关于set的基础知识以及vector ，set ，iterator的使用方法 set只能使用迭代器访问。 然后，记得考虑输
PAT甲级1021题，部分测试点无法通过
baosheyun0847的博客
08-01 2837
#include &lt;cstdio&gt; #include &lt;vector&gt; #include &lt;algorithm&gt; namespace PATA1021{     using namespace std;     const int MAXN=10001;     int n,maxH=0;     int father[MAXN];     bool is...
PAT甲级（Advanced Level）1021（图的最深根）
weixin_63780773的博客
11-08 277
PAT（Advanced Level）1021
PAT_甲级_1021
lzc842650834的博客
03-12 239
1021 Deepest Root A graph which is connected and acyclic can be considered a tree. The height of the tree depends on the selected root. Now you are supposed to find the root that results in a highest ...
PAT(甲级)1021
Leonardo1897的博客
09-24 685
1021. Deepest Root (25) 时间限制 1500 ms 内存限制 65536 kB 代码长度限制 16000 B 判题程序 Standard 作者 CHEN, Yue A graph which is connected and acyclic can b
PAT甲级编程题解：1001A+B与1002A+B代码实现
"该资源为PAT甲级编程考试的题解代码集合，包含179道题目的解决方案，适用于准备PAT甲级考试的学习者。" 在这份资源中，你可以找到针对PAT甲级考试的一些典型编程题目的解答。题目类型包括简单的算术运算以及更复杂...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值