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;
}