2025年十六届蓝桥杯Python B组原题及代码解析

相关试题可以在洛谷上测试用例：

2025 十六届 蓝桥杯 Python B组

试题 A：攻击次数

答案：103

print(103)

代码：

# 初始化敌人的血量
x = 2025

# 初始化回合数
turn = 0

# 模拟攻击过程
while x > 0:
    # 回合数加一
    turn += 1

    # 第一个英雄的攻击
    hero1 = 5

    # 第二个英雄的攻击
    if turn % 2 == 1:  # 奇数回合
        hero2 = 15
    else:  # 偶数回合
        hero2 = 2

    # 第三个英雄的攻击
    if turn % 3 == 1:  # 回合数除以 3 的余数为 1
        hero3 = 2
    elif turn % 3 == 2:  # 回合数除以 3 的余数为 2
        hero3 = 10
    else:  # 回合数除以 3 的余数为 0
        hero3 = 7

    # 总攻击值
    total = hero1 + hero2 + hero3

    # 更新敌人的血量
    x -= total

# 输出游戏结束时的回合数
print(turn)

试题 B：最长字符串

答案：afplcu

print('afplcu')

将word.txt文件与你的python代码文件保存在同一个文件夹下：

# 读取 words.txt 文件中的单词
with open("words.txt", "r") as f:
    ws = [line.strip() for line in f]

# 按长度和字典序排序
ws.sort(key=lambda x: (len(x), x))

# 初始化优美字符串集合
bs = set()

# 动态规划：判断每个单词是否是优美字符串
for w in ws:
    if len(w) == 1:
        bs.add(w)
    else:
        pre = ''.join(sorted(w[:-1]))
        if any(''.join(sorted(s)) == pre for s in bs):
            bs.add(w)

# 找到最长的优美字符串
ml = max(len(w) for w in bs)
lbs = [w for w in bs if len(w) == ml]

# 输出字典序最小的结果
print(min(lbs))

试题 C：LQ图形

代码：

w, h, v = map(int, input().split())

for i in range(h):
    for j in range(w):
        print("Q", end = "")
    print()

for i in range(w):
    for j in range(w + v):
        print("Q", end = "")
    print()

试题 D：最多次数

代码：

# 获取输入字符串
s = input()

# 初始化计数器
count = 0

# 遍历字符串，检查每个长度为3的子串
for i in range(len(s) - 2):
    substring = s[i:i+3]
    
    # 检查是否是目标模式之一
    if substring in {'lqb', 'lbq', 'qlb', 'qbl', 'blq', 'bql'}:
        count += 1
        # 为了避免重复计数，可以在找到一个模式后跳出当前循环
        break

# 输出不同模式的数量
print(count)

试题 E：A · B Problem

代码：

# 读取输入的 L 值
L = int(input())
max_L = L  # 最大范围为 L

# 预处理每个数的约数数目
d = [0] * (max_L + 1)  # 创建一个数组 d，用于存储每个数的约数数目
for i in range(1, max_L + 1):
    # 对于每个 i，将其所有倍数的约数计数加 1
    for j in range(i, max_L + 1, i):
        d[j] += 1

# 计算前缀和数组
prefix_sum = [0] * (max_L + 1)  # 创建一个数组 prefix_sum，用于存储约数数目的前缀和
current_sum = 0  # 当前的累积和
for i in range(1, max_L + 1):
    current_sum += d[i]  # 累加当前数的约数数目
    prefix_sum[i] = current_sum  # 将累积和存入前缀和数组

# 计算总答案
total = 0  # 初始化总答案
for m in range(1, max_L + 1):
    remainder = L - m  # 计算剩余值，即 L - m
    if remainder >= 0:  # 如果剩余值非负，则可以继续计算
        # 累加满足条件的组合数
        # d[m] 表示 m 的约数数目，prefix_sum[remainder] 表示剩余值的约数数目的前缀和
        total += d[m] * prefix_sum[remainder]

# 输出最终结果
print(total)

试题 F：园艺

代码：

def max_trees(n, heights):
    # dp[i] 是一个字典，表示以第 i 棵树为结尾时，不同间隔 d 对应的最长递增子序列长度
    dp = [{} for _ in range(n)]
    
    # 初始化：每棵树单独成一个子序列
    for i in range(n):
        dp[i][0] = 1  # 初始间隔为 0，长度为 1
    
    # 动态规划填表
    for i in range(n):
        for j in range(i):
            if heights[j] < heights[i]:  # 只有当高度递增时才更新
                d = i - j  # 计算间隔
                if d in dp[j]:
                    dp[i][d] = max(dp[i].get(d, 1), dp[j][d] + 1)
                else:
                    dp[i][d] = max(dp[i].get(d, 1), 2)  # 至少长度为 2
    
    # 找到所有 dp[i][d] 中的最大值
    max_length = 1
    for i in range(n):
        if dp[i]:
            max_length = max(max_length, max(dp[i].values()))
    
    return max_length

# 输入处理
n = int(input())
heights = list(map(int, input().split()))

# 输出结果
print(max_trees(n, heights))

试题 G：书架还原

代码：

def func(n, a):
    visited = [False] * (n + 1)  # 标记是否访问过，索引从 1 开始
    cycles = 0  # 环的数量

    for i in range(1, n + 1):  # 遍历每本书
        if not visited[i]:  # 如果未访问过
            cycles += 1  # 发现一个新的环
            x = i
            while not visited[x]:  # 沿着环追踪
                visited[x] = True
                x = a[x - 1]  # 下一本书的位置（注意索引从 0 开始）

    return n - cycles  # 最少操作次数


# 输入处理
n = int(input())
a = list(map(int, input().split()))

# 输出结果
print(func(n, a))

试题 H：异或和

代码：

n = int(input())  # 输入数组长度
a = list(map(int, input().split()))  # 输入数组
res = 0  # 最终结果

for b in range(31):  # 遍历每一位（0到30位）
    m = 1 << b  # 当前位的掩码，用于提取该位的值
    c = [0, 0]  # 用于统计当前位为0和1的数量
    s = [0, 0]  # 用于记录当前位为0和1的索引和
    cur = 0  # 当前位的贡献值

    for i in range(n):  # 遍历数组中的每个元素
        bit = (a[i] >> b) & 1  # 提取当前元素在当前位的值（0或1）
        cur += c[1 - bit] * i - s[1 - bit]  # 计算当前位的贡献值
        c[bit] += 1  # 更新当前位的计数
        s[bit] += i  # 更新当前位的索引和

    res += cur * m  # 将当前位的贡献值乘以掩码，累加到最终结果

print(res)  # 输出最终结果