打完后复盘来着的,有些题目忘记了。
问题描述
请找到一个大于 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 的位置连通的所有位置(包括自己)组成一个连通分块。
请问矩阵中最大的连通分块有多大?
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
b f s 算出最大块, p y t h o n 方便写 bfs算出最大块,python方便写 bfs算出最大块,python方便写
答案: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
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 个字符。
#include
#include
#include
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都取最大值,每次清理都是所有区域,不做重复判断的话就是 10 0 3 100^3 1003,执行100w次,我觉得行。
#include
#include
#include
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
在考试的时候没做出来,有点可惜。
问题描述
小蓝准备在一个空旷的场地里面滑行,这个场地的高度不一,小蓝用一个 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都有代码
题目既然没有给起点,那么遍历所有点是肯定的了,剩下的问题就是怎么遍历。这个数据量用深度优先显然是不行的,那么只能通过记忆每个节点的最优解,减少复杂度。
d p ( i , j ) 表示从该点出发最多能走的步数。 dp(i,j)表示从该点出发最多能走的步数。 dp(i,j)表示从该点出发最多能走的步数。
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()
#include
#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;
}
这题我无语,考的时候一直在想用动态规划解,一结束立马就会了呵呵。还好不是正式比赛。