【蓝桥杯】回顾第十、十一届一些略有难度但可以拿下的题_蓝桥杯第第十一届跟第十届的差距-CSDN博客

本文链接：https://blog.csdn.net/weixin_47383889/article/details/115771167

【蓝桥杯】回顾第十届C/C++B组、第十一届Python组那些略有难度但可以拿下的题

试题 A: 组队（第十届）
试题 E: 迷宫（第十届）
试题 C: 跑步锻炼（第十一届）
试题 G: 单词分析（第十一届）
试题 H: 数字三角形（第十一届）
总结

试题 A: 组队（第十届）

【问题描述】
作为篮球队教练，你需要从以下名单中选出1号位至5号位各一名球员，组成球队的首发阵容。
每位球员担任1号位至5号位时的评分如下表所示。请你计算首发阵容1号位至5号位的评分之和最大可能是多少?

team.text

1 97 90 0 0 0
2 92 85 96 0 0
3 0 0 0 0 93
4 0 0 0 80 86
5 89 83 97 0 0
6 82 86 0 0 0
7 0 0 0 87 90
8 0 97 96 0 0
9 0 0 89 0 0
10 95 99 0 0 0
11 0 0 96 97 0
12 0 0 0 93 98
13 94 91 0 0 0
14 0 83 87 0 0
15 0 0 98 97 98
16 0 0 0 93 86
17 98 83 99 98 81
18 93 87 92 96 98
19 0 0 0 89 92
20 0 99 96 95 81

【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

这道题我们可以使用DFS（深度优先搜索）来做，以编号1-20的球员为1号位时，DFS搜索所有组合找出评分之和最大的即可。

【答案】 490

def dfs(value, index):
    global Max, vis, v
    if index > 5:
        Max = max(Max, value)
        return
    for i in range(20):
        if not vis[i]:
            vis[i] = True
            dfs(value+v[i][index], index+1)
            vis[i] = False


Max = -1
vis = [False]*20
# 读取数据
v = [list(map(int, input().split())) for _ in range(20)]
# 以编号i为1号位循环遍历，搜索所有的组合结果，获取最大的组合数
for i in range(20):
    vis[i] = True
    dfs(v[i][1], 2)
    vis[i] = False
print(Max)

试题 E: 迷宫（第十届）

【问题描述】
下图给出了一个迷宫的平面图，其中标记为1的为障碍，标记为0的为可以通行的地方。

010000 000100 001001 110000

迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这个它的上、下、左、右四个方向之一。
对于上面的迷宫，从入口开始，可以按DRRURRDDDR的顺序通过迷宫，一共10步。其中D、U、L、R分别表示向下、向上、向左、向右走。
对于下面这个更复杂的迷宫（30行50列)，请找出一种通过迷宫的方式，其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。请注意在字典序中D<L<R<U。(如果你把以下文字复制到文本文件中，请务必检查复制的内容是否与文档中的一致。在试题目录下有一个文件maze.txt，内容与下面的文本相同)
maze.txt

01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000

【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个字符串，包含四种字母D、U、L、R，在提交答案时只填写这个字符串，填写多余的内容将无法得分。

这是一道迷宫问题，对于判断迷宫是否走得通或者找到走出迷宫的所有路线，我们通常使用DFS（深度优先遍历）；对于找到走出迷宫的最短路线，我们通常使用BFS（广度优先遍历）。
Python的数据结构设计得很优秀，列表即可作为栈或队列使用，如果要实现队列，append方法实现入队列，pop(0)方法实现出队列；如果要实现堆栈，append方法实现入栈，pop()方法实现出栈。

【答案】 _{DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR}

def bfs(i: int, j: int):
    '''
    BFS广度优先遍历，找到出迷宫的最短路线
    '''
    queue = [(i, j)]  # 初始化队列
    result = []
    vis[i][j] = True  # 标记已走过

    # 队列为空或找到出口时结束循环
    while len(queue):
        x, y = queue[0]
        result.append(queue[0])  # 保存路径
        queue.pop(0)  # 出队列
        if x == n-1 and y == m-1:
            return result
        for i in range(4):
            x, y = result[-1][0]+dirs[i][0], result[-1][1]+dirs[i][1]
            if 0 <= x <= n-1 and 0 <= y <= m-1 and not vis[x][y] and atr[x][y] == 0:
                queue.append((x, y))
                vis[x][y] = True
    return None

def settle(path: list):
    '''
    处理路线，从BFS中杂乱的路线列表path中提取出一条路线
    '''
    result = [path[-1]]
    i = len(path)-1
    while True:
        if i == 0:
            break
        for j in range(i-1, -1, -1):
            if abs(path[i][0]-path[j][0]) + abs(path[i][1]-path[j][1]) == 1:
                result.append(path[j])
                i = j
                break
    return list(reversed(result))

def print_path(path: list):
    '''
    将[(i1, j1), (i2, j2), ……]的路线转换成UDRL的形式
    '''
    if not len(path):
        return "此路不通"
    atr = []
    for i in range(1, len(path)):
        x = path[i][0] - path[i-1][0]
        y = path[i][1] - path[i-1][1]
        if x == -1 and y == 0:
            atr.append("U")
        if x == 0 and y == 1:
            atr.append("R")
        if x == 1 and y == 0:
            atr.append("D")
        if x == 0 and y == -1:
            atr.append("L")
    return "".join(atr)

n, m = map(int, input().split())
atr = [tuple(map(int, input())) for _ in range(n)]
dirs = ((-1, 0), (0, 1), (1, 0), (0, -1))
vis = [[False]*m for i in range(n)]
path = bfs(0, 0)
print(f"未处理的路线：{(path)}")
print(path)
if path:
    print(f"处理后的路线：{settle(path)}")
    print(f"打印：{print_path(settle(path))}")

试题 C: 跑步锻炼（第十一届）

【问题描述】
小蓝每天都锻炼身体。
正常情况下，小蓝每天跑1千米。如果某天是周一或者月初(1日)，为了激励自己，小蓝要跑2千米。如果同时是周一或月初，小蓝也是跑2千米。
小蓝跑步已经坚持了很长时间，从2000年1月1日周六（含）到2020年10月1日周四（含)。请问这段时间小蓝总共跑步多少千米?

这是一道模拟类的题目，涉及到日期，因此我们需要调用Python的datetime标准库。题目本身不难，用datetime库可以轻松解决，但如果使用Excel则难度较高。同时，建议不会使用datetime库的同学学习一下。

【答案】 8879

from datetime import date, timedelta
now = date(2000, 1, 1)
end = date(2020, 10, 1)
count = 0
while now <= end:
    if now.day == 1 or now.weekday() == 0:
        # 使用day属性判断是否为月初，使用weekday()方法判断是否为周一
        count += 1
    count += 1
    now = now + timedelta(days=1)
print(count)

试题 G: 单词分析（第十一届）

时间限制: 1.0s 内存限制:512.0MB
【问题描述】
小蓝正在学习一门神奇的语言，这门语言中的单词都是由小写英文字母组成，有些单词很长，远远超过正常英文单词的长度。小蓝学了很长时间也记不住一些单词，他准备不再完全记忆这些单词，而是根据单词中哪个字母出现得最多来分辨单词。
现在，请你帮助小蓝，给了一个单词后，帮助他找到出现最多的字母和这个字母出现的次数。
【输入格式】
输入一行包含一个单词，单词只由小写英文字母组成。

【输出格式】
输出两行，第一行包含一个英文字母，表示单词中出现得最多的字母是哪个。如果有多个字母出现的次数相等，输出字典序最小的那个。

【样例输入】
lanqiao

【样例输出】
a
2
【样例输入】
longlonglongistoolong

【样例输出】
o
6

【评测用例规模与约定】
对于所有的评测用例，输入的单词长度不超过1000。

主要考察对Python字符串的运用，首先读取字符串，然后使用集合set对字符串进行去重并遍历，设置全局变量Max记录出现次数最多的字符及其次数，使用count(ch)方法获取字符在字符串中的出现次数并与Max比较。注意，当字符出现的次数相同时，需要比较字典序。

s = input()
Max = ['0', 0]  # Max[0]表示在字符串s中次数出现最多次的字符，Max[1]表示该字符出现的次数
for i in set(s):  # 使用集合set去重
    count = s.count(i)  # str.count(ch)方法可以计算ch在str中的出现次数
    if count > Max[1] or (count == Max[1] and i < Max[0]):
        Max = [i, count]
print(f"{Max[0]}\n{Max[1]}")

试题 H: 数字三角形（第十一届）

时间限制:1.0s 内存限制:512.0MB

7 3 8 8 1 0 2 7 4 4 4 5 2 6 5

上图给出了一个数字三角形。从三角形的顶部到底部有很多条不同的路径。对于每条路径，把路径上面的数加起来可以得到一个和，你的任务就是找到最大的和。
路径上的每一步只能从一个数走到下一层和它最近的左边的那个数或者右边的那个数。此外，向左下走的次数与向右下走的次数相差不能超过1。

【输入格式】
输入的第一行包含一个整数N(1 < N ≤ 100)，表示三角形的行数。下面的N行给出数字三角形。数字三角形上的数都是0至100之间的整数。

【输出格式】
输出一个整数，表示答案。

【样例输入】
5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

【样例输出】
27

这是一道动态规划题。设存储三角形的列表为matrix，当前点为matrix[i][j]，只能走向左下matrix[i+1][j]或向右下matrix[i+1][j+1]。设dp存储当前这条路的最大值，dp[i][j]只能由左上dp[i-1][j-1]或dp[i-1][j]走到。因此，动态规划的数学公式为
$\begin{cases} dp[i-1][j] + matrix[i][j], & \text{$j$ = 0} \\ max(dp[i-1][j-1], dp[i-1][j]) + matrix[i][j], & \text{0 < $j$ < $i$} \\ dp[i-1][j-1] + matrix[i][j], & \text{$j$ = $i$} \end{cases}$
因为题目要求向左下走的次数与向右下走的次数相差不能超过1，因此
$\begin{cases} dp[-1][n//2], & \text{$n$为奇数} \\ max(dp[-1][n//2-1], dp[-1][n//2]), & \text{$n$为偶数} \end{cases}$

n = int(input())  # 输入的N
matrix = [(list(map(int, input().split()))) for _ in range(n)]  # 存储输入的值

dp = [[0 for _ in range(n)] for _ in range(n)]  # 存储最大值
dp[0][0] = matrix[0][0]

for i in range(1, n):
    for j in range(i+1):
        if j == 0:
            # 第一列
            dp[i][j] = dp[i-1][j] + matrix[i][j]
        elif j == i:
            # 当前行的最后一列
            dp[i][j] = dp[i-1][j-1] + matrix[i][j]
        else:
            dp[i][j] = max(dp[i-1][j-1], dp[i-1][j]) + matrix[i][j]

# 题目有个要求，就是向左下走的次数与向右下走的次数相差不能超过1
# 因此，只有中间的才符合。若n为奇数则为最中间的那个，若n为偶数则取最中间两个较大的那个
result = dp[-1][n//2] if n % 2 == 1 else max(dp[-1][n//2-1], dp[-1][n//2])
print(result)