2023蓝桥杯校内模拟赛第三期_在 excel 中,列的名称使用英文字母的组合。前 26 列用一个字母,依次为 a 到 z,接

前言

打完后复盘来着的，有些题目忘记了。

第一题

问题描述
　　请找到一个大于 2022 的最小数，这个数转换成十六进制之后，所有的数位（不含前导 0）都为字母（A 到 F）。
　　请将这个数的十进制形式作为答案提交。
答案提交
　　这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

1
2
3
4
5
6

解析

可以先用格式化输出16进制的2022，发现2022的十六进制是7E6，那么根据题目要求，答案就是AAA转为10进制。

第二题

问题描述
　　在 Excel 中，列的名称使用英文字母的组合。前 26 列用一个字母，依次为 A 到 Z，接下来 26*26 列使用两个字母的组合，依次为 AA 到 ZZ。
　　请问第 2022 列的名称是什么？
答案提交
　　这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个由大写字母组成的字符串，在提交答案时只填写这个字符串，填写多余的内容将无法得分。

1
2
3
4
5
6
7

解析

直接使用拖拽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 的位置连通的所有位置（包括自己）组成一个连通分块。
　　请问矩阵中最大的连通分块有多大？
答案提交
　　这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

解析

$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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

第六题

问题描述
　　给定一天是一周中的哪天，请问 n 天后是一周中的哪天？
输入格式
　　输入第一行包含一个整数 w，表示给定的天是一周中的哪天，w 为 1 到 6 分别表示周一到周六，w 为 7 表示周日。
　　第二行包含一个整数 n。
输出格式
　　输出一行包含一个整数，表示 n 天后是一周中的哪天，1 到 6 分别表示周一到周六，7 表示周日。
样例输入
6
10
样例输出
2
评测用例规模与约定
　　对于所有评测用例，1 <= n <= 1000000。
1
2
3
4
5
6
7
8
9
10
11
12
13
14

解析

周期性，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;
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

第七题

问题描述
　　输入一个字符串，请判断这个字符串是否正好是 lanqiao 。在输入时如果只是大小写不同也算作相同。
输入格式
　　输入一行包含一个字符串。
输出格式
　　如果是 lanqiao ，输出全小写的字符串 yes ，否则输出全小写的字符串 no 。
样例输入
LanQiao
样例输出
yes
样例输入
QiaoLan
样例输出
no
评测用例规模与约定
　　对于所有评测用例，输入的字符串由大写或小写英文字母组成，长度至少为 1 个字符，不超过 20 个字符。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

解析

1. 大小写无要求
2. 目标串正好是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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

第九题

问题描述
　　小蓝有一个 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。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

解析

我简单算了一下，假设n,m都取最大值，每次清理都是所有区域，不做重复判断的话就是$100^3$，执行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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

第十题

在考试的时候没做出来，有点可惜。

问题描述
　　小蓝准备在一个空旷的场地里面滑行，这个场地的高度不一，小蓝用一个 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

解析

C和Python都有代码
题目既然没有给起点，那么遍历所有点是肯定的了，剩下的问题就是怎么遍历。这个数据量用深度优先显然是不行的，那么只能通过记忆每个节点的最优解，减少复杂度。

记忆化搜索

$dp(i,j)表示从该点出发最多能走的步数。$

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()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

这题我无语，考的时候一直在想用动态规划解，一结束立马就会了呵呵。还好不是正式比赛。