2022年PAT乙级春考

孙鹏宇
119 阅读12分钟

B-1暴力破解 (15 分)

旅行箱上的密码锁

image.png

通常都只有 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

思想

暴力枚举所有的排列组合


#include<bits/stdc++.h>
using namespace std;
int a[20];
int n;
int main()
{
	cin >> n;
	for (int i = 0; i < n; i++)cin >> a[i];
	sort(a,a+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++)
			{
				printf("%s%d%d%d",cnt?" ":"",a[i],a[j],a[k]);
				cnt++;
				if (cnt == 10)
				{
					printf("\n");
					cnt = 0;
				}
			}

	return 0;
}













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

思想

用一个haxi存每个学生的id和出现次数，最后输出次数最多的学生id和出现次数。用一个sum[]存每个id的在各个科目的学时总和，输出次数最多的学生的id的学时。

#include<bits/stdc++.h>
using namespace std;
const int N = 5010;

int n;
int Time;  //每一科目的学时
int maxn;
string id;
map<string,int>sum;
map<string, int>haxi;


	struct CMP
	{
		bool operator()(pair<string, int>& a, pair<string, int>& b)
		{
			return a.second < b.second;
		}
	};

int main()
{
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		cin >> Time;

		int k; cin >> k;
		for (int i = 0; i < k; i++)
		{
			cin >> id;
			cout << "id:" << id << " ";
			haxi[id]++;         //求每个学生(id)的出现次数
			sum[id] += Time;   //求每个学生（id)的学时和
		}
		cout << endl;
	}

	//按照升序排，最后方便升序输出
	vector<pair<string, int>> v(haxi.begin(), haxi.end());
	sort(v.begin(), v.end(), CMP());  //排个序，按招first降序输出
	    
	
	//求一下最大出现次数
		for (auto& it : haxi)
		{
			if (it.second > maxn)
			{
				maxn = it.second;
			}
 		}


		//找一下所有和最大出现次数相同的id
		int MaxTime=0, MaxObjet=0;
		int z = 0;
		string ans[N];
		for (auto& it : haxi)
		{
			if (it.second == maxn)
			{
				MaxTime = sum[it.first];
				MaxObjet = it.second;
				ans[z] = it.first;
				z++;
			}
		}
		cout << MaxTime << " " << MaxObjet << endl;
	
		for (int i = 0; i < z; i++)cout << ans[i]<<" ";
	return 0;
}













B-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.

思想

按照题意要求做即可，题意说了3个要求：

1.一个老师不能在工作的时间休息。

2.两间教室不能在同一时刻供两个教师同时上课。

3.一个老师不能同时给两个班上课。

这道题的难点在输出顺序上。

code

#include<bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10,M=50;
int sleep[M];
bool flag[N];
int n, m, k;

struct C
{
	int Time, room;
}Class[N];
int main()
{
	cin >> n >> m >> k;
	for (int i = 1; i <=n; i++)
	{
		int t; cin >> t;
		for (int j = 1; j <= t; j++)
		{
			cin >> sleep[j];
		}
		cin >> Class[i].Time >> Class[i].room;
		for (int z = 1; z <= t; z++)
		{
			if (sleep[z] == Class[i].Time)
			{
				flag[i] = true;
			}
		}
	}
	for (int l = 1; l <n; l++)
	{
		for(int y= l+1;y<=n;y++)
		{
			if (Class[l].Time == Class[y].Time && Class[l].room == Class[y].room)
			{
				printf("ERROR: Conflict between %d and %d.\n",y,l);
			}
	
		}
	}

	for(int i=1;i<=n;i++)
	if (flag[i])
	{
		printf("ERROR: Conflict with instructor for %d.\n", i);
	}
	


	return 0;
}

image.png

正解

#include <bits/stdc++.h>
using namespace std;
const int N = 10010;

struct Point {
	int L, T[50], Time, room;
} K[N];
int n, m, k;
bool flag1, flag2, all;


//bool cmp(struct Point a, struct Point b) {
//	for (int i = 0; i < n; i++) {
//		for (int j = 0; j < a[i].L; j++) {
//			return a[i].T[j] < b[i].T[j];
//		}
//	}
//}

int cmp(const void *a, const void *b) {
	return *(int *)a - *(int *)b;
}

void solve() {

	cin >> n >> m >> k;

	for (int i = 0; i < n; i++) {
		cin >> K[i].L;

		flag1 = false, flag2 = false;
		for (int j = 0; j < K[i].L; j++) {
			cin >> K[i].T[j];
		}

		cin >> K[i].Time >> K[i].room;

		qsort(K[i].T, K[i].L, sizeof(K[0].T[0]), cmp);
		//sort(K, k + n, cmp);

		if (i) {
			for (int m = 0; m < i; m++) {
				if (K[i].room == K[m].room && K[m].Time == K[i].Time) {//校验是否存在教室冲突
					printf("ERROR: Conflict between %d and %d.\n", i + 1, m + 1);
					flag1 = 1;
					all = 1;
				}
			}
		}

		if (bsearch(&K[i].Time, K[i].T, K[i].L, sizeof(K[0].T[0]), cmp)) { //校验是否存在时间冲突
			printf("ERROR: Conflict with instructor for %d.\n", i + 1);
			flag2 = 1;
			all = 1;
		}


		if (flag1 || flag2) { //必须先将两个条件都检验一遍才能初始化
			K[i].Time = -1 * i;
			K[i].room = -1 * i;
		}
	}

	if (!all)
		printf("Perfect Arrangement for %d classes!\n", n);
}

int main() {

	cin.tie(nullptr)->sync_with_stdio(0);
	int t = 1;
	while (t--) {
		solve();
	}
	return 0;
}

image.png












B-4简易测谎 (20 分)

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

首先我们要求被测试者做完 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!!!

思想

模拟题，按照题意把所有情况都枚举出来，对每个情况都进行处理就可以，一定可以写出来，就是有许多细节需要处理。

code

#include <bits/stdc++.h>
using namespace std;
int n, t, k;
int sum, cnt1, cnt2;
bool flagcnt1, flagcnt2;

int main() {
	cin >> n >> t >> k;
	for (int i = 0; i < k; i++) {
		string s;
		cin >> s;

		//每一轮重置
		sum = 0, cnt1 = 0, cnt2 = 0;
		flagcnt1 = false, flagcnt2 = false;


		for (int j = 0; j < s.size(); j++) {
			//以 f 开头的，得分 ?2；
			if (j == 0 && s[j] == 'f') {
				sum -= 2;
			}

			//以 a 结尾的，得分 ?1；
			if (j == s.size() - 1 && s[j] == 'a') {
				sum -= 1;
			}

			//对于每一段长度大于 5 的连续选择同一字母的最长子串，得分 +3；
			if (j < s.size() && s[j + 1] == s[j]) {
				cnt1++;
			} else {
				cnt1 = 0;
				flagcnt1 =
				    false;  //比如说aaaaaabbbbbb，aaaaaa满足当前条件+=3，然后此时bbbbbb时候cnt1=0，flagcnt1自然也要重置为0，要从头开始计数
			}
			if (cnt1 >= 5 && !flagcnt1) {
				sum += 3;
				flagcnt1 = true;
			}


			//a 后面紧跟 e 或 h 的，得分 ?4；
			if ((s[j] == 'a' && s[j + 1] == 'e') || (s[j] == 'a' && s[j + 1] == 'h')) {
				sum -= 4;
			}


			//对于每一段长度大于 3 的连续选择相邻递增字母的最长子串（例如 abcd 或 defgh），得分 +5。
			if (j < s.size() && s[j + 1] - s[j] == 1) {
				cnt2++;
			} else {
				cnt2 = 0;
				flagcnt2 = false;
			}
			if (cnt2 >= 3 && !flagcnt2) {
				sum += 5;
				flagcnt2 = true;
			}
		}

		if (sum > t)
			cout << sum << "!!!" << endl;
		else
			cout << sum << endl;
	}

	return 0;
}

image.png














7-5 前K大数 (25 分)

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

输入格式：

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

输出格式：

按递减序在一行中输出前 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

一眼priority_queue板子题目，一遍过。

坑点 当k大于n的时候，例如样例2，会产生预想外的结果：

image.png

因此，当k大于n的时候，我们让k=n即可。

image.png

code

#include <bits/stdc++.h>
using namespace std;
priority_queue<int>q;
int n, k;

int main() {
	cin >> n >> k;

	for (int i = 0; i < n; i++) {
		int x;
		cin >> x;
		q.push(x);
	}
	int cnt = 0;
	if (k > n)
		k = n;
	while (k--) {

		int t = q.top();
		//cout << "t: " << t << endl;
		if (cnt == 0) {
			cout << t;
		} else
			cout << " " << t;
		q.pop();
		cnt++;
	}

	return 0;
}

image.png

avatar
文章
阅读
粉丝