2022春季PAT乙级 姑且算是题解&打卡（4题卡数据WA，C++）

更新：网上看到了其他dalao的c语言满分题解，写的比我好多了……放个链接吧
传送门 https://blog.csdn.net/SepMiranda/article/details/123342268

---

2022春季PAT乙级 打卡（4题卡数据，C++）

两百块钱娱乐一场，只拿了95有点丢人了，问题不大，在这里简单记录一下2333333

花絮：刚开始考试的时候旁边座位那哥们用的青轴声音好激烈啊，自己前四十分钟从第一个题看到最后愣是一个完整的程序都憋不出来紧张死了（笑）还是从第5个题倒着写的

正文开始

---

7-1 暴力破解 (15 分)

题干：

旅行箱上的密码锁通常都只有 3 位数字，如果忘了密码，只要有足够的耐心，哪怕用逐一枚举的办法，也可以暴力破解。如果还能隐约记得数字的范围，则可以大大降低破解的工作量。

本题就请你根据用户记忆中的数字范围，列出所有可能的密码。

输入格式：

输入第一行给出一个正整数 n（≤8），随后一行列出 n 个 0 - 9 范围内的数字，是用户记忆中可能属于密码的数字。题目保证 n 个数字没有重复，数字间以空格分隔。

输出格式：

按照密码组成的 3 位数从小到大的顺序，输出这 n 个数字能组成的所有可能的 3 位数密码。要求每行输出 10 个，同行数字以 1 个空格分隔，行首尾不得有多余空格。注意：如果有前导零，也不可忽略。

输入样例：

3
5 2 8

输出样例：

222 225 228 252 255 258 282 285 288 522
525 528 552 555 558 582 585 588 822 825
828 852 855 858 882 885 888

思路：

没啥好说的，用列表前n位存放可能存在的数字，sort一下遍历三次就好，简单

代码：

#include <cstdio>
#include <algorithm>
#define fo(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
    int st[12]={0};
    int n;
    scanf("%d", &n);
    fo (i, n)
        scanf("%d", &st[i]);
    sort(st, st+n);
    int cnt = 0, max=n*n*n;
    fo (i, n){
        fo (j, n){
            fo (k, n){
                printf("%d%d%d%c", st[i], st[j], st[k], (++cnt%10==0||cnt==max) ?'\n':' ');
            }
        }
    }
    return 0;
}

---

7-2 学霸 (20 分)

题干：

所谓“学霸”，就是每个学期选课学时最长的人。本题就给你所有课程的学时和选课名单，请你找出那个学霸。如果有总学时并列最多的情况，则选那个选课门数最多的。如果还有并列，就按学号升序输出他们吧~

输入格式：

输入在第一行中给出一个正整数：\(N（≤5000）\)为课程总数。随后 N 行，每行给出一门课的选课信息，格式如下

学时 人数 选课人1 选课人2 ……

其中 学时 是该课程的学时，一个不超过 100 的正整数；人数 是该课程的选课人数，为不超过 200 的非负整数；选课人i 是第 i 个选课学生的编号，是一个 5 位数字。题目保证不同学生对应的编号不同，且同一门课程的选课名单中没有重复的学生。

输出格式：

首先在一行中输出学霸（们）的选课总学时和门数，随后在下一行中按照编号升序输出所有满足题面描述的学霸。编号间以 1 个空格分隔，行首尾不得有多余空格。题目保证至少存在一位学霸。

输入样例：

5
32 5 10001 00003 91032 02387 10993
64 2 36775 91032
16 3 10993 02387 36775
16 4 02387 56772 10993 00003
32 3 10993 02387 88024

输出样例：

96 4
02387 10993

思路：

这个题自己处理的不好，方法太蠢了（程序和人有一个能跑就行2333333

定义结构体，包含学号学时科目数，再写一个比较函数（cmp）用于排序。定义超大的列表，对于每一次读入的选课情况，在下标为学号的位置加上学时科目数并存入学号（防止排序后学号丢失），并用计数器储存学霸数量和学霸课时数&科目书

接下来sort一下学时为0的家伙应该就都跑到后面了，按照计数器的数量打印前几名学号就好。

代码：

#include <cstdio>
#include <algorithm>
#define N 100010
using namespace std;
struct stu{
    int id, h, n;
};
stu ls[N];
bool cmp(stu &a, stu &b){
    return a.h!=b.h ? (a.h>b.h) : (a.n!=b.n ? (a.n>b.n) : (a.id < b.id));
}
int main(){
    int sumn;
    scanf("%d", &sumn);
    for (int i = 0; i < sumn; i++){
        int h,stunum,tmpstu;
        scanf("%d %d", &h, &stunum);
        for (int j = 0; j < stunum; j++){
            scanf("%d", &tmpstu);
            ls[tmpstu].id=tmpstu;
            ls[tmpstu].h+=h;
            ls[tmpstu].n++;
        }
    }
    sort(ls, ls+N, cmp);
    int maxtime=ls[0].h, maxn=ls[0].n;
    printf("%d %d\n%05d", maxtime, maxn, ls[0].id);
    int i = 1;
    while (ls[i].h==maxtime && ls[i].n==maxn)
        printf(" %05d", ls[i++].id);
    return 0;
}

---

7-3 排课 (20 分)

题干：

排课是个世界难题。

假设每个学期有 \(N\) 个教学班的课需要排，每周有 \(M\) 个时间段可以上课，全校共有 \(K\) 间教室，不同排课组合方案的个数可能会超过整个宇宙的质子数。更为复杂的是，每个学期排课前，学校还会收集每个教学班任课老师不能上课的时间段，还要保证排课不与老师的时间安排起冲突。

当然，本题不是要求你实现一个排课算法，而是要求你实现一个排课方案检查算法。即给定每个教学班上课的时间和地点，你需要检查这个时间段和地点是否只有这一个班上课，并且这个上课时间不会正好是任课老师不能上课的时间。

输入格式：

输入在第一行中给出三个正整数：\(N\)（\(≤10^4\)）为教学班总数；\(M\)（\(≤40\)）为一周内上课时间段的个数；\(K\)（\(≤10^3\)）为教室总数。数字间以空格分隔。以下我们就将教学班、时间段、教室分别从 1 开始顺序编号。

随后 N 行，每行给出一个教学班的任课教师时间限制和排课的信息。格式如下：

L T[1] ... T[L] Time Room

其中 L 是任课教师的时间限制数量（\(<M\)），后面给出 L 个该老师不能上课的时间段编号；Time 是该教学班安排的上课时间段编号，Room 是上课教室编号。我们假设每个教学班的任课老师都不一样。

输出格式：

如果给定的课表安排是完全无冲突的，则在一行内输出：Perfect Arrangement for N classes! 其中 N 是教学班数量。

如果课表有冲突，则需要输出冲突原因。我们首先假设教学班是按照编号递增序进行排课的，教学资源先到先得。如果后面安排的教学班 A 跟前面的教学班 B 排在了同一个时间和地点，则在一行中输出 ERROR: Conflict between A and B.，此时教学班 A 暂不安排。如果教学班 A 的上课时间跟任课教师有冲突，则在一行中输出 ERROR: Conflict with instructor for A.。当两种冲突都发生时，分两行输出，先输出教学班冲突的信息。

输入样例 1：

5 20 10
2 1 5 10 7
0 10 3
5 2 4 6 8 10 3 3
3 10 3 18 15 1
1 20 19 10

输出样例 1：

Perfect Arrangement for 5 classes!

输入样例 2：

5 20 10
2 1 5 10 7
0 10 7
5 2 4 6 8 10 6 3
3 10 3 18 6 3
2 20 10 10 7

输出样例 2：

ERROR: Conflict between 2 and 1.
ERROR: Conflict with instructor for 3.
ERROR: Conflict between 5 and 1.
ERROR: Conflict with instructor for 5.

思路：

整行的不定长度读入，想了想还是用了getline+stringstream（应该有更好的方案，stringstream很慢很慢数据量大会爆，也就这次测试点时间要求不高），用二维数组存储x教室在y时间的使用情况，若未使用填入班级序号（1开始计算，0为无人使用）；以及一个一维数组存当前教师的繁忙时间

用x记录当前行有无错误（控制是否向当前教室.时间的位置写入当前班级序号），haserr记录全局有无错误（无错误时输出完美

接下来按照题意跟着模拟就好，如果两种错误同时出现的话好想要按顺序把两个错都报一遍……

代码：

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

short used[1010][50];//room, time

int main(){
    int cls, tm, room;
    cin >> cls >> tm >> room;
    bool haserr=0;
    string st;getline(cin, st);
    for (int c = 0; c < cls; c++){
        string strin;
        getline(cin, strin);
        stringstream ss;
        ss << strin;
        short errtm, errtime[50]={0}, t;
        ss >> errtm;
        for (int i = 0; i < errtm; i++){
            ss >> t;errtime[t]=1;
        }
        
        short time, room;
        bool x=0;
        ss >> time >> room;
        if (used[room][time]){
            cout << "ERROR: Conflict between " << c+1 << " and " << used[room][time] << ".\n";
            haserr=x=1;
        }
        if (errtime[time]){
            cout << "ERROR: Conflict with instructor for "<<c+1<<".\n";
            haserr=x=1;
        }
        if(!x)
            used[room][time]=c+1;
    }
    if (!haserr)cout << "Perfect Arrangement for " << cls << " classes!";
    return 0;
}

---

7-4 简易测谎 (15 / 20 分，卡测试点1和4)

最后一个多小时都在和这个题斗智斗勇，后四五十分钟都在和最后卡住的两个数据搏斗……这是个悲伤的故事

题干：

测谎通常使用一套准备好的问题提问被测试者，通过分析被测试者的反应得到结果。比较高级的测谎技术会使用测谎仪，监视被测试者的生理活动状况。我们这里的简易测谎则是通过对问题答案的特征分析来做出判断。

首先我们要求被测试者做完 \(N\) 道单选题，每道题有 8 个选项，由小写英文字母 a - h 来表示。这样就得到一个长度为 \(N\) 的、由 a - h 小写英文字母组成的字符串。对每个字符串打分，得分超过某个给定阈值 T 的就判断为“疑似说谎者”。打分原则如下：

• 以 f 开头的，得分 \(−2\)；
• 以 a 结尾的，得分 \(−1\)；
• 对于每一段长度大于 5 的连续选择同一字母的最长子串，得分 \(+3\)；
• a 后面紧跟 e 或 h 的，得分 \(−4\)；
• 对于每一段长度大于 3 的连续选择相邻递增字母的最长子串（例如 abcd 或 defgh），得分 \(+5\)。

本题就请你写程序完成对被测试者的判断。

输入格式：

输入第一行给出 3 个正整数：\(N\)（\(6≤N≤100\)）为测谎问卷的题目数；\(T\) （\(≤100\)）为判断说谎的得分阈值；\(K\)（\(≤100\)）为被测试者人数。

随后 \(K\) 行，每行给出一个被测试者的答案字符串。

输出格式：

对每个被测试者的答案，在一行中输出其得分。如果分数超过阈值，则在其分数后输出 !!!。

输入样例：

12 1 6
fghaebcdeddd
ahhhhhhgbaaa
cdefffffffff
fffffghecaaa
feeeeeeeegcb
aaaaaabbbbbb

输出样例：

-1
-2
8!!!
-3
1
6!!!

思路：

试着按题意模拟但卡两个测试点

自己的思路是第一阶段判断开头结尾，然后第二阶段find查找指定字符串（目前测试过的：两个中任意出现一个分数-=4一次，或者每出现一次就分数-4一次都没有在卡住的测试点改变结果），第三阶段查找重复与连续递增的字串（但是我没看懂题目中连续选择同一字母的最长子串和连续选择相邻递增字母的最长子串的“最长”到底指的是什么，按样例应该是每找到一次连续重读长度>5或者连续递增长度>3就对分数做一次处理呀……可能是我理解有误

蹲一个dalao的题解或者我再查查看吧……

代码（WA，卡测试点1和4）：

#include <iostream>
#define nop string::npos
#define min(a, b) a<b?a:b
using namespace std;
int judge(string &s, int len){
    int sco = 0;
    // 依据题意，先判定开头结尾字符
    if (s.front()=='f')sco-=2;
    if (s.back()=='a')sco--;
    
    // 尝试循环查找ah和ae，若有多个则多次加分，但不起作用
    // 如果只对s.substr(st).find("ae")!=nop||s.suebstr(st).find("ah")!=nop
    // 判断一次并sco-=4的话依旧不影响，似乎测试点不是在这里卡住的
    int st = 0, st2=0;
    while (st2+st < len-1){
        if(s.substr(st).find("ae")!=nop&&s.substr(st).find("ah")!=nop){
            // 
            sco-=4;
            st=min(s.substr(st).find("ae"), s.substr(st).find("ah"))+1;
            st2+=st=1;
        } else if (s.substr(st).find("ae")!=nop){
            sco-=4;
            st=s.substr(st).find("ae")+1;
            st2+=st+1;
        } else if (s.substr(st).find("ah")!=nop){
            sco-=4;
            st=s.substr(st).find("ah")+1;
            st2+=st+1;
        }else st=len;
    }
    
    int i = 1, lsame=5;
    while (i < len){
        int samecnt = 0;
        bool hassame = 0;
        for (; i < len; i++){
            samecnt = s[i] == s[i-1] ? samecnt+1 : 0;
            if (samecnt>=lsame){
                hassame=1;
                sco+=3;
                break;
            }
        }
        if(i==len)break;
        if(hassame){
            i++;
            while (s[i]==s[i-1]&&i<len)
                i++, lsame++;
        }else i++;
    }
    i=1;
    int ld=3;
    while (i < len){
        int dcnt = 0;
        bool hasd = 0;
        for (; i < len; i++){
            dcnt = (s[i] == (s[i-1]+1)) ? dcnt+1 : 0;
            if (dcnt>=ld){
                hasd=1;
                sco+=5;
                break;
            }
        }
        if(i==len)break;
        if(hasd){
            i++;
            while (s[i]==(s[i-1]+1)&&i<len)
                i++,ld++;
        }else i++;
    }
    return sco;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    //cout << s.front() << '|'<<s.back();
    int n, t, k;// 等于t不报警
    cin >> n >> t >> k;
    for (int i = 0; i < k; i++){
        string ans;
        cin>>ans;
        //cout << ans.size()<<'|';
        int score = judge(ans, n);
        cout << score << (score>t ? "!!!" : "") << endl;
    }
    return 0;
}

---

7-5 前K大数 (25 分)

题干：

本题目标非常简单：给定 \(N\) 个整数，找出前 \(K\) 个最大的数，并按递减序输出。

时间&内存限制：

• Java (javac) 2000ms, 300MB

• Python2/3 2200ms, 5MB

• 其他 150ms, 2MB

输入格式：

输入第一行给出 2 个正整数 \(N\) (\(≤10^6\)) 和 \(K\) (\(≤5\))。随后一行给出 \(N\) 个整数键值，范围在区间 \([−230,230]\) 内，以空格分隔。

输出格式：

按递减序在一行中输出前 $K% 个最大的数。

注意：一行中输出的数字间须以 1 个空格分隔，行首尾不得有多余空格。

输入样例 1：

10 4
40 25 60 -15 30 -21 80 -1 -5 27

输出样例 1：

80 60 40 30

输入样例 2：

4 5
23 -17 99 1

输出样例 2：

99 23 1 -17

思路：

时空卡的有点紧（自己测试点3和4都卡在了100ms附近），如果全部读入肯定不行

取了个巧，定义一个小数组，前6个都取到比下限更小一点的位置，接下来对于求前k个最大值，如果输入的新数据比第k个大，那么把新数据写进第k+1个位置并对数组的第0~k+1个数据sort一下

但是有点隐患，如果每次输入的新数据都更大的话（比如1~1e6的递增序列）每输入一个数据就会排序一次，这种特殊情况的话俺寻思应该是要超时的（自己太菜不知道怎么在单机测试这种超大数据），也是侥幸这次考试的测试点没撞上，暂时AC

代码：

#include <cstdio>
#include <algorithm>
const int MIN = -(1<<30)-2;
using namespace std;
bool cmp(int &a, int &b){return a > b;}
int main(){
    int q[7]={MIN,MIN,MIN,MIN,MIN,MIN};
    int n, k;
    scanf("%d %d", &n, &k);
    if (n<=0||k<=0){putchar('\n');return 0;}
    for (int i = 0; i < n; i++){
        scanf("%d", &q[k]);
        if (q[k]>q[k-1])sort(q, q+k+1, cmp);
    }
    int len = k <n ? k : n;
    for (int i = 0; i < len; i++)
        printf("%s%d", i==0?"":" ", q[i]);
    return 0;
}