PAT（乙级）2022年春季考试答案

鲁B Coder_li

于 2024-08-31 23:21:19 发布

阅读量848

点赞数 15

文章标签：算法 pat考试

本文链接：https://blog.csdn.net/Q_Express/article/details/141760264

版权

7-1 暴力破解

旅行箱上的密码锁通常都只有 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

AC代码：

先对输入的数组进行排序后，三次循环输出即可，中间使用cnt计数器判断换行时机。

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

int main()
{
	int n;
	cin >> n;
	int password[10];
	for(int i = 0; i < n; i++)
	{
		cin >> password[i];
	}
	sort(password, password + n);
	int cnt = 0;
	for(int i = 0; i < n; i++){
		for(int j = 0; j < n; j++){
			for(int k = 0; k < n; k++){
				if(cnt)
					cout << " ";
				cout << password[i] << password[j] << password[k];
				cnt++;
				if(cnt == 10){
					cout << "\n";
					cnt = 0;
				}
			}
		}
	}
	return 0;
}

7-2 学霸

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

输入格式：

输入在第一行中给出一个正整数：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

AC代码：

定义Student结构体，重写Student的排序方法，保证排序按照学时、门数降序和学号升序排序。排序完之后学时最大，门数其次，并用两个变量记录后输出，最后学时相同时判断门数相同的都进行输出打印即可。

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

struct Student{
	int id = 0;
	int sumHour = 0;
	int sumChoice = 0;
};

Student s[100000];

bool cmp(Student s1, Student s2)
{
	if(s1.sumHour == s2.sumHour){
		if(s1.sumChoice == s2.sumChoice){
			return s1.id < s2.id;
		}
		return s2.sumChoice < s1.sumChoice;
	}
	return s2.sumHour < s1.sumHour;
}

int main()
{
	int N;
	cin >> N;
	for(int i = 0; i < N; i++)
	{
		int studyHour, choiceStu;
		cin >> studyHour >> choiceStu;
		for(int j = 0; j < choiceStu; j++){
			int stuid;
			cin >> stuid;
			s[stuid].id = stuid;
			s[stuid].sumHour += studyHour;
			s[stuid].sumChoice++;
		}
	}
	sort(s, s + 100000, cmp);
	int maxHour = s[0].sumHour;
	int maxChoice = s[0].sumChoice;
	cout << maxHour << " " << maxChoice << endl;
	int p = 0;
	while(true)
	{
		if(s[p].sumHour == maxHour && s[p].sumChoice == maxChoice){
			if(p){
				cout << " ";
			}
			printf("%05d", s[p].id);
			p++;
		}else{
			break;
		}
	}
	return 0;
}

7-3 排课

排课是个世界难题。

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

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

输入格式：

输入在第一行中给出三个正整数：N（≤104）为教学班总数；M（≤40）为一周内上课时间段的个数；K（≤103）为教室总数。数字间以空格分隔。以下我们就将教学班、时间段、教室分别从 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.

AC代码：

定义结构体Classroom，Time为时间，Room为房间，sets为教师有事情的时间集合。getError判断是否冲突，设置标志位flag默认为1，当出现冲突置flag为0即可，最后输出打印。

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

struct Classroom{
	set<int> sets;
	int Time;
	int Room;
};

Classroom cr[10005];

int getError(int index);

int main()
{
	int N, M, K;
	cin >> N >> M >> K;
	int flag = 1;
	for(int i = 1; i <= N; i++)
	{
		int L;
		cin >> L;
		for(int j = 0; j < L; j++)
		{
			int c;
			cin >> c;
			cr[i].sets.insert(c);
		}
		cin >> cr[i].Time >> cr[i].Room;
		int res = getError(i);
		if(res != 0){
			flag = 0;
			cout << "ERROR: Conflict between " << i << " and " << res << "." << endl;
			cr[i].Room = -1;
		}
		if(cr[i].sets.find(cr[i].Time) != cr[i].sets.end()){
			flag = 0;
			cout << "ERROR: Conflict with instructor for " << i << "." << endl;
			cr[i].Room = -1;
		}
	}
	if(flag){
		cout << "Perfect Arrangement for "<< N <<" classes!" << endl;
	}
	return 0;
}

int getError(int index)
{
	for(int i = 0; i < index; i++){
		if(cr[i].Time == cr[index].Time && cr[i].Room == cr[index].Room){
			return i;
		}
	}
	return 0;
}

7-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!!!

AC代码：

根据打分原则，使用getScore对每一条分数score进行五项测试后加减即可。

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

int getScore(string s);

int main()
{
	int N, T, K;
	cin >> N >> T >> K;
	getchar();
	for(int i = 0; i < K; i++)
	{
		string choice;
		getline(cin, choice);
		int res = getScore(choice);
		cout << res;
		if(res > T){
			cout << "!!!" << endl;
		}else{
			cout << "\n";
		}
	}
	return 0;
}

int getScore(string s)
{
	int score = 0;
	if(s[0] == 'f'){
		score -= 2;
	}
	
	if(s[s.length() - 1] == 'a'){
		score -= 1;
	}
	
	for(int i = 0; i < s.length(); i++){
		char c = s[i];
		int cnt = 0;
		while(s[i] == c){
			cnt++;
			i++;
		}
		if(cnt > 5){
			score += 3;
		}
		i--;
	}
	
	for(int i = 0; i < s.length(); i++){
		if(i + 1 < s.length() && s[i] == 'a' && (s[i + 1] == 'e' || s[i + 1] == 'h')){
			score -= 4;
		}
	}
	
	for(int i = 0; i < s.length(); i++){
		char c = s[i];
		int cnt = 0;
		while(s[i] == c){
			cnt++;
			c++;
			i++;
		}
		if(cnt > 3){
			score += 5;
		}
		i--;
	}
	
	return score;
}

7-5 前K大数

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

输入格式：

输入第一行给出 2 个正整数 N (≤106) 和 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

代码限制：

代码长度限制    16 KB
Java (javac)        时间限制    2000 ms    内存限制    300 MB
Python (python3)    时间限制    2200 ms    内存限制    5 MB
Python (python2)    时间限制    2200 ms    内存限制    5 MB
其他编译器    时间限制    150 ms    内存限制    2 MB
栈限制    8192 KB

AC代码：

核心思路：本题相当于在极短的时间与极小的空间中找前K大数。

极短的时间：再短也得遍历完整个数组，那就只遍历一遍数组！

极小的空间：再小也得有K（≤ 5）个空间存储，那就开5个空间。

例如当前遍历的num大于v[0]，记得要先将后面的

p[4] = p[3];
p[3] = p[2];
p[2] = p[1];
p[1] = p[0];
最后： p[0] = num；

最后，记得用scanf和printf进行输入输出即可。

#include "iostream"
using namespace std;

int main()
{
	int N, K;
	scanf("%d %d", &N, &K);
	long long p[5];
	for(int i = 0; i < 5; i++)
	{
		p[i] = -1073741824;
	}
	for(int i = 0; i < N; i++)
	{
		long long num;
		scanf("%lld", &num); 
		if(num > p[0]){
			p[4] = p[3];
			p[3] = p[2];
			p[2] = p[1];
			p[1] = p[0];
			p[0] = num;
		}else{
			if(num > p[1]){
				p[4] = p[3];
				p[3] = p[2];
				p[2] = p[1];
				p[1] = num;
			}else{
				if(num > p[2]){
					p[4] = p[3];
					p[3] = p[2];
					p[2] = num;
				}else{
					if(num > p[3]){
						p[4] = p[3];
						p[3] = num;
					}else{
						if(num > p[4]){
							p[4] = num;
						}
					}
				}
			} 
		}
	}
	if(N >= K){
		for(int i = 0; i < K; i++){
			if(i)
				printf(" ");
			printf("%lld", p[i]);
		}
	}else{
		for(int i = 0; i < N; i++){
			if(i)
				printf(" ");
			printf("%lld", p[i]);
		}
	}
	return 0;
}