前言
打完后复盘来着的，有些题目忘记了。
第一题
问题描述
请找到一个大于 2022 的最小数，这个数转换成十六进制之后，所有的数位（不含前导 0）都为字母（A 到 F）。
请将这个数的十进制形式作为答案提交。
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
解析
可以先用格式化输出16进制的2022，发现2022的十六进制是7E6，那么根据题目要求，答案就是AAA转为10进制。
第二题
问题描述
在 Excel 中，列的名称使用英文字母的组合。前 26 列用一个字母，依次为 A 到 Z，接下来 26*26 列使用两个字母的组合，依次为 AA 到 ZZ。
请问第 2022 列的名称是什么？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个由大写字母组成的字符串，在提交答案时只填写这个字符串，填写多余的内容将无法得分。
解析
直接使用拖拽excel到2022列。如果想敲代码可以理解成26进制。
第三题忘了，第四题就是两个for循环，判断一下是否大于等于2022。
第五题
老实说，当时没这么看明白是什么玩意。
问题描述
小蓝有一个 30 行 60 列的数字矩阵，矩阵中的每个数都是 0 或 1 。
110010000011111110101001001001101010111011011011101001111110
010000000001010001101100000010010110001111100010101100011110
001011101000100011111111111010000010010101010111001000010100
101100001101011101101011011001000110111111010000000110110000
010101100100010000111000100111100110001110111101010011001011
010011011010011110111101111001001001010111110001101000100011
101001011000110100001101011000000110110110100100110111101011
101111000000101000111001100010110000100110001001000101011001
001110111010001011110000001111100001010101001110011010101110
001010101000110001011111001010111111100110000011011111101010
011111100011001110100101001011110011000101011000100111001011
011010001101011110011011111010111110010100101000110111010110
001110000111100100101110001011101010001100010111110111011011
111100001000001100010110101100111001001111100100110000001101
001110010000000111011110000011000010101000111000000110101101
100100011101011111001101001010011111110010111101000010000111
110010100110101100001101111101010011000110101100000110001010
110101101100001110000100010001001010100010110100100001000011
100100000100001101010101001101000101101000000101111110001010
101101011010101000111110110000110100000010011111111100110010
101111000100000100011000010001011111001010010001010110001010
001010001110101010000100010011101001010101101101010111100101
001111110000101100010111111100000100101010000001011101100001
101011110010000010010110000100001010011111100011011000110010
011110010100011101100101111101000001011100001011010001110011
000101000101000010010010110111000010101111001101100110011100
100011100110011111000110011001111100001110110111001001000111
111011000110001000110111011001011110010010010110101000011111
011110011110110110011011001011010000100100101010110000010011
010011110011100101010101111010001001001111101111101110011101
如果从一个标为 1 的位置可以通过上下左右走到另一个标为 1 的位置，则称两个位置连通。与某一个标为 1 的位置连通的所有位置（包括自己）组成一个连通分块。
请问矩阵中最大的连通分块有多大？
答案提交
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
解析
答案：148
"""
temp_s 是目标字符串根据行切分的字符串列表
"""
dc = {"0":True,"1":False}
s = []
s.append([True]*(len(temp_s[0])+2))
for i in temp_s:
s.append([True]+[dc[_] for _ in i]+[True])
s.append([True]*(len(temp_s[0])+2))
dirc = [[0,-1],[0,1],[1,0],[-1,0]] # 左右下上
def bfs(x,y):
if s[x][y]: # 如果起始点被访问过则退出
return 0
# 队列
q = [(x,y)]
# 块大小
size = 1
# 起始点被访问
s[x][y] = True
while q:
xy = q.pop(0)
for k in dirc:
# 没有被标记
# print(xy[0]+k[0],xy[1]+k[1])
if not s[xy[0]+k[0]][xy[1]+k[1]]:
# 块大小+1
size += 1
# 保存该点，用于扩散
q.append((xy[0]+k[0],xy[1]+k[1]))
# 标记访问
s[xy[0]+k[0]][xy[1]+k[1]] = True
return size
max_size = 0
for x in range(1,len(s)-1):
for y in range(1,len(s[0])-1):
max_size = max(max_size,bfs(x,y))
# print(bfs(x,y))
print(max_size)
第六题
问题描述
给定一天是一周中的哪天，请问 n 天后是一周中的哪天？
输入格式
输入第一行包含一个整数 w，表示给定的天是一周中的哪天，w 为 1 到 6 分别表示周一到周六，w 为 7 表示周日。
第二行包含一个整数 n。
输出格式
输出一行包含一个整数，表示 n 天后是一周中的哪天，1 到 6 分别表示周一到周六，7 表示周日。
样例输入
6
10
样例输出
2
评测用例规模与约定
对于所有评测用例，1 <= n <= 1000000。
解析
周期性，w无论是周几，完后数7就会回到原位，所以把n多余的7滤掉，剩下的就是需要往后数的天数。直接（w+n)%7，但要注意，如果w+n刚好是7的倍数，结果就是0，并不是正确答案。
#include <stdio.h>
int main()
{
int w,n;
scanf("%d %d",&w,&n);
if((w+n)%7==0){
printf("7");
}
else{
printf("%d",(w+n)%7);
}
return 0;
}
第七题
问题描述
输入一个字符串，请判断这个字符串是否正好是 lanqiao 。在输入时如果只是大小写不同也算作相同。
输入格式
输入一行包含一个字符串。
输出格式
如果是 lanqiao ，输出全小写的字符串 yes ，否则输出全小写的字符串 no 。
样例输入
LanQiao
样例输出
yes
样例输入
QiaoLan
样例输出
no
评测用例规模与约定
对于所有评测用例，输入的字符串由大写或小写英文字母组成，长度至少为 1 个字符，不超过 20 个字符。
解析
- 大小写无要求
- 目标串正好是7个字符
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
int i;
char ch[21];
scanf("%s",ch);
if(strlen(ch) != 7){ // 筛掉长度不符合的
printf("no");
return 0;
}
char* cmp = "lanqiao";
for(i=0;i<7;i++){ // 比较7个字符就行
if(ch[i]>=97){ // 大小写判断
if(ch[i] != cmp[i]){ // 一次不相等就返回no
printf("no");
return 0;
}
}
else{
ch[i] += 32;
if(ch[i] != cmp[i]){
printf("no");
return 0;
}
}
}
printf("yes"); // 所有条件满足就是yes
return 0;
}
第九题
问题描述
小蓝有一个 n * m 大小的矩形水域，小蓝将这个水域划分为 n 行 m 列，行数从 1 到 n 标号，列数从 1 到 m 标号。每行和每列的宽度都是单位 1 。
现在，这个水域长满了水草，小蓝要清理水草。
每次，小蓝可以清理一块矩形的区域，从第 r1 行（含）到第 r2 行（含）的第 c1 列（含）到 c2 列（含）。
经过一段时间清理后，请问还有多少地方没有被清理过。
输入格式
输入第一行包含两个整数 n, m，用一个空格分隔。
第二行包含一个整数 t ，表示清理的次数。
接下来 t 行，每行四个整数 r1, c1, r2, c2，相邻整数之间用一个空格分隔，表示一次清理。请注意输入的顺序。
输出格式
输出一行包含一个整数，表示没有被清理过的面积。
样例输入
2 3
2
1 1 1 3
1 2 2 2
样例输出
2
样例输入
30 20
2
5 5 10 15
6 7 15 9
样例输出
519
评测用例规模与约定
对于所有评测用例，1 <= r1 <= r2 <= n <= 100, 1 <= c1 <= c2 <= m <= 100, 0 <= t <= 100。
解析
我简单算了一下，假设n,m都取最大值，每次清理都是所有区域，不做重复判断的话就是，执行100w次，我觉得行。
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int nm[101][101] = {{0}}; // 没有清理的地方都是0
int main()
{
int n,m,t;
scanf("%d %d",&n,&m);
scanf("%d",&t);
int sum = n*m; // 总共需要清理的数量
int i,r1,r2,c1,c2,j,k,size=0;
for(i=0;i<t;i++){ // 三个for，够暴力了
scanf("%d %d %d %d",&r1,&c1,&r2,&c2); // 读入一次坐标清理一次
for(j=r1-1;j<r2;j++){ // 根据坐标枚举清理区域
for(k=c1-1;k<c2;k++){
if(nm[j][k] == 0){
nm[j][k] = 1; // 被清理了就是1
++size; //清理一个地方+1
}
}
}
if(size == sum) // 提前结束循环，因为全部清理了就不需要继续清理了
break;
}
printf("%d",sum-size); // 总需清理 - 已清理 = 未清理数量
return 0;
}
第十题
在考试的时候没做出来，有点可惜。
问题描述
小蓝准备在一个空旷的场地里面滑行，这个场地的高度不一，小蓝用一个 n 行 m 列的矩阵来表示场地，矩阵中的数值表示场地的高度。
如果小蓝在某个位置，而他上、下、左、右中有一个位置的高度（严格）低于当前的高度，小蓝就可以滑过去，滑动距离为 1 。
如果小蓝在某个位置，而他上、下、左、右中所有位置的高度都大于等于当前的高度，小蓝的滑行就结束了。
小蓝不能滑出矩阵所表示的场地。
小蓝可以任意选择一个位置开始滑行，请问小蓝最多能滑行多远距离。
输入格式
输入第一行包含两个整数 n, m，用一个空格分隔。
接下来 n 行，每行包含 m 个整数，相邻整数之间用一个空格分隔，依次表示每个位置的高度。
输出格式
输出一行包含一个整数，表示答案。
样例输入
4 5
1 4 6 3 1
11 8 7 3 1
9 4 5 2 1
1 3 2 2 1
样例输出
7
样例说明
滑行的位置一次为 (2, 1), (2, 2), (2, 3), (3, 3), (3, 2), (4, 2), (4, 3)。
评测用例规模与约定
对于 30% 评测用例，1 <= n <= 20，1 <= m <= 20，0 <= 高度 <= 100。
对于所有评测用例，1 <= n <= 100，1 <= m <= 100，0
解析
C和Python都有代码
题目既然没有给起点，那么遍历所有点是肯定的了，剩下的问题就是怎么遍历。这个数据量用深度优先显然是不行的，那么只能通过记忆每个节点的最优解，减少复杂度。
记忆化搜索
Python 版本
python有cache装饰器，用于保存指定参数的返回值，将代码量减少，使用也很方便。
不理解装饰器可以看我这篇python闭包与装饰器。
# python3
import functools
# 写成class好看一点
class longestRoad:
dirc = [[0,-1],[0,1],[1,0],[-1,0]] # 左右下上
# 初始化
def __init__(self) -> None:
# 存输入数据
self.n,self.m = map(int,input().split())
self.nm = []
# 两面包
self.nm.append([100000000]*(self.m+2))
# 额外增加边界
for i in range(self.n):
self.nm.append([100000000]+list(map(int,input().split()))+[100000000])
self.nm.append([100000000]*(self.m+2))
# 夹芝士
# 使用 @cache 装饰器，不设置缓存大小限制
@functools.cache
def dp(self,i,j): # i,j点最多可以走的 步数
dp_res = 0
for k in self.dirc:
if self.nm[i][j] > self.nm[i+k[0]][j+k[1]]:
dp_res = max(dp_res,self.dp(i+k[0],j+k[1])+1)
return dp_res
# 所有节点遍历
def _traversalNode(self):
res = 1
# 将每个点作为起始点
for i in range(1,self.n+1):
for j in range(1,self.m+1):
for k in self.dirc:
# 判断是否可以走
if self.nm[i][j] > self.nm[i+k[0]][j+k[1]]:
# 更新最优解
res = max(res,self.dp(i+k[0],j+k[1])+2) # 可以从某点走到下一个点就+1，起点也是那个大哥划过来的，所有也算+1，所以+2
return res
def run(self):
print(self._traversalNode())
longestRoad().run()
C 语言版本
#include <stdio.h>
#define MAX 100000000 // 边界值
int nm[102][102] = {{0}}; // 存输入数据
int xy_max[102][102] = {{0}}; // xy点出发的最多可滑行
int dirc[4][2] = {{0,-1},{0,1},{1,0},{-1,0}}; // 左右下上
int dp(x,y){ // x,y点的最多可以走 的步数，即xy点的最优解
// 该点是否已经被求解最优
if(xy_max[x][y] > -1) return xy_max[x][y];
// 搜索该点的最优解
int k=0,res=0;
for(;k<4;k++){ // 四个方向
if(nm[x][y] > nm[x+dirc[k][0]][y+dirc[k][1]]){ // xy是否可以往k方向走
res = dp(x+dirc[k][0],y+dirc[k][1])+1; // 能走即步数+1并加上下一个点的最优解
xy_max[x][y] = res> xy_max[x][y]? res: xy_max[x][y]; // 保留这几个方向中的最优解
}
}
// 返回该点最优解
return xy_max[x][y];
}
int main()
{
int n,m;
scanf("%d %d",&n,&m);
int i,j,k;
for(i=0;i<=n+1;i++){
for(j=0;j<=m+1;j++){
if(i==0 || i==n+1 || j==0 || j==m+1) // 设置边界，防止移动时跑出
nm[i][j] = MAX;
else scanf("%d",nm[i]+j); // 不是边界则存入数据
xy_max[i][j] = -1; // 最优解状态初始化
}
}
// 任意点为起点进行遍历，那啥划到出发点也算1
int res; // 每个方向的最优解
int max=1;
for(i=1;i<=n;i++){
for(j=1;j<=m;j++){
for(k=0;k<4;k++){
// xy是否可以往k走
if(nm[i][j] > nm[i+dirc[k][0]][j+dirc[k][1]]){
// 可以从该点走到下一个点就+1，起点本身也算+1，所以+2
res = dp(i+dirc[k][0],j+dirc[k][1])+2; // 用一个遍历接收是为了防止重复开栈空间
xy_max[i][j] = res>xy_max[i][j]?res:xy_max[i][j]; // 保留每个方向出发的最优解
max = max>xy_max[i][j]? max:xy_max[i][j]; // 记录最大值
}
}
}
}
printf("%d",max);
return 0;
}
这题我无语，考的时候一直在想用动态规划解，一结束立马就会了呵呵。还好不是正式比赛。
文章出处登录后可见！
已经登录？立即刷新
