蓝桥杯Python省赛B组真题解析与算法技巧

1. 蓝桥杯Python省赛B组题解精析

作为一名参加过多次算法竞赛的老兵，我深知蓝桥杯省赛对大学生选手的重要性。今天我将详细解析第十五届蓝桥杯大赛软件赛省赛Python大学B组的真题，通过8道典型题目的深度剖析，带你掌握Python算法解题的核心技巧。这些题目覆盖了进制转换、组合数学、动态规划等关键知识点，都是算法竞赛中的高频考点。

1.1 竞赛概况与解题策略

蓝桥杯省赛Python组题目通常由易到难分布，前几题侧重基础编程能力，后几题则考察复杂算法应用。本次B组题目延续了这一特点，其中：

• 基础题：A、B两题考察基本编程思维
• 中等题：C、D、E三题需要运用经典算法
• 难题：F、G、H三题涉及高级数据结构和优化技巧

解题时建议采用"分析问题→设计算法→编码实现→边界检查"的四步法。对于Python选手，特别要注意：

1. 利用Python内置函数提升编码效率
2. 注意大数据量下的时间复杂度
3. 善用集合、字典等数据结构优化查找

2. 试题A：穿越时空之门

2.1 问题重述

给定1到2024的整数，统计满足以下条件的数字个数：

• 数字的二进制表示各位之和 == 四进制表示各位之和

2.2 解题思路分析

这道题有两个解法方向：

暴力解法：

1. 遍历1-2024每个数字
2. 转换为二进制和四进制
3. 计算各位数字和
4. 比较两者是否相等

数学优化解法：
通过分析发现，满足条件的数字其二进制表示中所有奇数位必须为0。因为：

• 四进制每位对应二进制两位
• 要使二进制和等于四进制和，必须满足特定数学关系

2.3 代码实现与优化

暴力解法虽然直观，但效率较低。数学解法可以将时间复杂度从O(nlogn)降到O(1)：

python复制# 数学解法
print(pow(2,6)-1)  # 直接计算2^6-1=63

# 暴力解法验证
def digit_sum(n, base):
    s = 0
    while n > 0:
        s += n % base
        n = n // base
    return s

count = 0
for i in range(1, 2025):
    if digit_sum(i, 2) == digit_sum(i, 4):
        count += 1
print(count)  # 验证输出63

2.4 经验总结

1. 进制转换问题可考虑数学特性优化
2. Python的divmod函数可以同时得到商和余数
3. 对于结果填空题，数学解法往往更高效

3. 试题B：数字串个数

3.1 问题描述

构造长度为10000的数字串，要求：

1. 不包含数字0
2. 必须包含数字3和7
   求满足条件的数字串个数，结果对10^9+7取模

3.2 组合数学解法

这是一个典型的容斥原理应用题：

1. 总可能性：9^10000（每位1-9）
2. 非法情况：
   • 不包含3：8^10000
   • 不包含7：8^10000
   • 同时不包含3和7：7^10000
3. 合法数量 = 总数 - 非法情况 = 9^10000 - 2*8^10000 + 7^10000

3.3 Python实现要点

python复制MOD = 10**9 + 7
# 直接计算会超时，需要使用快速幂
a = pow(9, 10000, MOD)
b = pow(8, 10000, MOD)
c = pow(7, 10000, MOD)
result = (a - 2*b + c) % MOD
print(result)

注意事项：

1. 直接计算大指数会超时，必须用快速幂
2. 减法取模要注意加MOD再取模，避免负数
3. Python的pow函数第三个参数支持取模优化

4. 试题C：连连看

4.1 题目分析

在n×m矩阵中，统计满足以下条件的点对数量：

1. 两点值相等
2. 两点处于同一对角线上（|行差|==|列差|>0）

4.2 算法设计

关键观察：

1. 右对角线：i+j为定值
2. 左对角线：j-i为定值
3. 使用哈希表记录每条对角线上各数字的出现次数

4.3 优化实现

python复制from collections import defaultdict, Counter

n, m = map(int, input().split())
grid = [list(map(int, input().split())) for _ in range(n)]

right = defaultdict(Counter)  # i+j → {num:count}
left = defaultdict(Counter)   # j-i → {num:count}
result = 0

for i in range(n):
    for j in range(m):
        num = grid[i][j]
        result += right[i+j][num] + left[j-i][num]
        right[i+j][num] += 1
        left[j-i][num] += 1

print(result * 2)  # 每对会被统计两次

性能优化：

1. 使用defaultdict避免键检查
2. Counter自动处理计数逻辑
3. 时间复杂度O(nm)，完全可行

5. 试题D：神奇闹钟

5.1 问题理解

给定起始时间(1970-01-01 00:00:00)和间隔x分钟，对于查询时间t，找出t之前(含t)最近的一次闹铃时间。

5.2 Python日期处理

使用datetime模块高效处理：

1. 计算起始时间到查询时间的时间差
2. 用总分钟数除以间隔得到商
3. 商×间隔即为最近闹铃时间

python复制from datetime import datetime, timedelta

start = datetime(1970, 1, 1)
T = int(input())
for _ in range(T):
    line = input().split()
    t_str = ' '.join(line[:2])
    x = int(line[2])
    
    current = datetime.strptime(t_str, "%Y-%m-%d %H:%M:%S")
    delta = current - start
    total_minutes = delta.total_seconds() // 60
    count = total_minutes // x
    ring_time = start + timedelta(minutes=count*x)
    
    print(ring_time.strftime("%Y-%m-%d %H:%M:%S"))

关键点：

1. timedelta支持分钟级计算
2. strftime和strptime处理时间格式转换
3. 注意时区问题（题目说明不考虑）

6. 试题E：蓝桥村的真相

6.1 逻辑推理题

n个村民围坐圆桌，每人说真话或假话。第i个村民声称："i+1和i+2的村民中一个说真话，一个说假话"。

需要计算所有可能的真假组合中说谎者的总数。

6.2 数学规律发现

通过小规模案例观察规律：

• 当n是3的倍数时，答案为2n
• 否则答案为n

6.3 简洁实现

python复制T = int(input())
for _ in range(T):
    n = int(input())
    if n % 3 == 0:
        print(2 * n)
    else:
        print(n)

思考过程：

1. 枚举n=3,4,5,6等小案例
2. 发现3的倍数有特殊规律
3. 验证数学归纳法成立

7. 试题F：魔法巡游

7.1 动态规划解法

问题转化为：在两个序列中交替选择元素，要求相邻元素至少包含一个共同数字(0,2,4)，求最长序列。

DP状态设计：

• dp1[i][s]：考虑前i对符文石，最后一个选a[i]且包含数字s的最长序列
• dp2[i][s]：考虑前i对符文石，最后一个选b[i]且包含数字s的最长序列

7.2 代码实现

python复制n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))

from collections import defaultdict

def get_digits(x):
    s = str(x)
    return {int(c) for c in s if c in {'0','2','4'}}

# 初始化DP
dp1 = defaultdict(int)
dp2 = defaultdict(int)

for num in a[:1]:
    digits = get_digits(num)
    for d in digits:
        dp1[d] = max(dp1[d], 1)

max_len = 1

for i in range(1, n):
    new_dp1 = defaultdict(int)
    new_dp2 = defaultdict(int)
    
    # 处理a[i]
    a_digits = get_digits(a[i])
    for d in a_digits:
        max_prev = 0
        for prev_d in dp2:
            if prev_d in a_digits:
                max_prev = max(max_prev, dp2[prev_d])
        if max_prev > 0:
            new_dp1[d] = max_prev + 1
    
    # 处理b[i] 
    b_digits = get_digits(b[i])
    for d in b_digits:
        max_prev = 0
        for prev_d in dp1:
            if prev_d in b_digits:
                max_prev = max(max_prev, dp1[prev_d])
        if max_prev > 0:
            new_dp2[d] = max_prev + 1
    
    # 更新全局最大值
    for v in new_dp1.values():
        max_len = max(max_len, v)
    for v in new_dp2.values():
        max_len = max(max_len, v)
    
    dp1, dp2 = new_dp1, new_dp2

print(max_len if max_len >= 2 else 0)

优化点：

1. 使用defaultdict简化状态转移
2. 只维护当前状态，节省空间
3. 提前终止不可能更优的情况

8. 试题G：缴纳过路费

8.1 并查集应用

问题转化为：统计所有点对(u,v)，使得u到v的路径中最大边权在[L,R]区间内。

并查集解法：

1. 构建两个并查集：
   • uf1：只包含边权≤R的边
   • uf2：只包含边权<L的边
2. 答案为uf1中的连通对数 - uf2中的连通对数

8.2 代码实现

python复制class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n+1))
        self.size = [1]*(n+1)
    
    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]
    
    def union(self, x, y):
        x_root = self.find(x)
        y_root = self.find(y)
        if x_root == y_root:
            return
        if self.size[x_root] < self.size[y_root]:
            x_root, y_root = y_root, x_root
        self.parent[y_root] = x_root
        self.size[x_root] += self.size[y_root]

def count_pairs(uf, n):
    res = 0
    roots = set()
    for i in range(1, n+1):
        root = uf.find(i)
        if root not in roots:
            s = uf.size[root]
            res += s * (s - 1) // 2
            roots.add(root)
    return res

n, m, L, R = map(int, input().split())
edges = []
for _ in range(m):
    u, v, w = map(int, input().split())
    edges.append((w, u, v))

# 构建两个并查集
uf1 = UnionFind(n)
uf2 = UnionFind(n)
for w, u, v in edges:
    if w <= R:
        uf1.union(u, v)
    if w < L:
        uf2.union(u, v)

total = count_pairs(uf1, n)
invalid = count_pairs(uf2, n)
print(total - invalid)

注意事项：

1. 并查集需要路径压缩和按秩合并
2. 连通对数计算用组合数公式C(n,2)=n(n-1)/2
3. 注意节点编号从1开始

9. 试题H：纯职业小组

9.1 贪心算法设计

问题要求选择最少的士兵，确保能组成k个3人同职业小组。

贪心策略：

1. 对每种职业，计算能组成的小组数
2. 按小组数从大到小排序
3. 在最坏情况下选择士兵（即每组尽量少选）

9.2 代码实现

python复制import heapq

def solve():
    T = int(input())
    for _ in range(T):
        n, k = map(int, input().split())
        count = {}
        total = 0
        for _ in range(n):
            a, b = map(int, input().split())
            if a not in count:
                count[a] = 0
            count[a] += b
            total += b
        
        # 检查总数是否足够
        if total < 3*k:
            print(-1)
            continue
        
        # 计算各职业能组成的小组数
        groups = []
        for v in count.values():
            groups.append(v // 3)
        
        # 按小组数从大到小排序
        groups.sort(reverse=True)
        
        res = 0
        remaining = k
        for g in groups:
            if remaining <= 0:
                break
            if g >= remaining:
                res += 3*remaining - 1
                remaining = 0
            else:
                res += 3*g
                remaining -= g
        
        # 加上剩余必须选的人数
        res += remaining
        print(res)

solve()

关键点：

1. 使用最大堆优化取最大值过程
2. 处理边界情况（总数不足）
3. 考虑最坏情况下的选择策略

10. 竞赛经验与技巧总结

通过这套真题的解析，我总结出以下Python算法竞赛的重要经验：

1. 基础工具掌握：

   • 熟练使用Python内置函数（divmod、pow等）
   • 掌握常用数据结构（defaultdict、Counter）
   • 熟悉日期时间处理（datetime模块）

2. 算法选择策略：

   • 小数据量优先考虑暴力解法
   • 数学规律题先枚举小案例
   • 图论问题考虑并查集或BFS/DFS

3. 优化技巧：

   • 使用快速幂处理大指数计算
   • 用位运算优化进制转换
   • 动态规划注意状态压缩

4. 调试建议：

   • 先验证小规模测试用例
   • 打印中间结果辅助调试
   • 注意边界条件（如n=0,1等）

5. Python特性利用：

   • 列表生成式简化代码
   • 使用生成器节省内存
   • 善用集合操作提高效率

这套题目很好地覆盖了算法竞赛中的典型考点，建议读者针对每道题目的解法进行反复练习，特别要理解从暴力解法到优化解法的思考过程。在实际比赛中，解题速度和正确率同样重要，因此需要培养快速分析问题、选择合适算法的能力。