2022 年省赛：我估计 48.5 分左右 (满分 150)。广东总共 78 个省一，我只排到了第 33 (42.3%)

2022 年国赛：最后一道大题没时间写 —— 暴力就能满分的题，血亏，最后国三

2023 年省赛：居然是全省第二 (广东 B 组省一共 91 人，前 2.1%)，差点没把我笑死

2023 年国赛：倒数第二题交的时候多了一个 print，只拿了国二

2024 年省赛：F 题列表越界访问了……省一但没什么好名次。赛前只是复习了 5 天，感觉太久没练新题题感下降了不少。9 月读研了没时间刷新题目，加上本校不办赛点了，应该不参加国赛了

在本篇文章中，我将从“知识预备”、“刷题网站”、“函数模板”三个方面为大家讲解怎样准备蓝桥杯 Python 组的比赛 —— 为什么不三连？！？

知识预备

开发环境

官方要求的是 IDLE，截至 2023 都是可以用 PyCharm 的 (具体还是要找组委会问清楚，不要问“能不能用”，要问“算不算作弊”)

2024.03.30 组委会 - 张老师：不能用 PyCharm，用了不算作弊

2024.04.03 组委会 - 刘老师：用 PyCharm 按作弊处理，函数名称补全不算作弊

2024.04.12 组委会 - 陈老师 (粤 / 宁)：用 PyCharm 不算作弊，但是结果自负

2024.04.12 组委会 - 刘老师：不能用

组委会没统一口径真的难顶

可以使用以下代码查看自己的 Python 版本

import sys

print(sys.version_info[:3])

以下是 PyCharm 和 IDLE 常用的快捷键 (如果以后比赛可以用 PyCharm 的话)

IDLE 代码提示

打开 IDLE 的代码提示，需要修改以下文件的代码 (假设 Python 的安装路径为 ~)：

• ~/Lib/idlelib/autocomplete.py：import <目标模块>

• ~/Lib/idlelib/config-extensions.def：popupwait= 0

帮助文档 (推荐)

IDLE 的代码提示有限，任何别名都会导致代码提示失效。比如 x = collections.Counter，x 会无法识别。所以建议结合 help("modules")、help、dir 函数使用

模块名称：help("modules")

关键字列表：keyword.kwlist

内置函数：dir(builtins)

函数 / 类 / 模块文档：help(func_cls_mod)

忘记某个函数的用法时，可以使用 help 函数查看说明文档

help 也可以用于查找模块的函数列表

类 / 模块属性：dir(cls_mod)

dir 函数既可查看模块的函数 / 对象列表，也可以查看对象的属性 / 方法列表

算法知识

具体考点可以看这篇文章： 

蓝桥杯大赛软件类备赛指南https://blog.csdn.net/weixin_43914593/article/details/128296251我主要看了这个网课的前 40 集，因为专业课学了树、图，所以重点放在了动态规划、背包、状态压缩、线段树

【蓝桥杯比赛】视频教程（入门学习+算法辅导）https://www.bilibili.com/video/BV1Lb4y1k7K3?

贪心算法的话，比较玄学，练习为主：LeetCode：贪心算法题集

Python 组和其它组的不同点在于，代码简洁在很多情况下约等于高效，例如：

• 求一个列表的最大值及其索引时，暴力的 max + index 比 for 循环更快
• 使用 class 写的线段树减少运算量时，运行时间反倒比暴力写法还长 (也有可能是我的类写得太烂)

所以在准备 Python 组的比赛时，一些算法是不需要学的。同时，因为 Python 的效率并不是和运算量直接挂钩，所以还要多对比不同写法所花费的时间：

import math


class timer:

    def __init__(self, repeat: int = 1, avg: bool = True):
        self.repeat = max(1, int(repeat) if isinstance(repeat, float) else repeat)
        self.avg = avg

    def __call__(self, func):
        import time

        def handler(*args, **kwargs):
            t0 = time.time()
            for i in range(self.repeat): func(*args, **kwargs)
            cost = (time.time() - t0) * 1e3
            return cost / self.repeat if self.avg else cost

        return handler


# 求 x! 关于 1398173074 的余数
mod = 1398173074


@timer(repeat=2)
def fun1(x):
    return math.factorial(x) % mod


@timer(repeat=10)
def fun2(x):
    result = 1
    for i in range(2, x + 1):
        result = result * i % mod
    return result


for f in [fun1, fun2]:
    print(f'Cost:\t{f(540880):.2f}\tms')

Cost:    3238.52    ms
Cost:    91.90        ms

对于 ，Python 1 秒内可以进行 8e7 次运算 (加法亦然)

比赛中题目的测评时间一般是 10 s 以上 (甚至有 30 s)，解题时根据问题规模设计好代码的时间复杂度

然后比赛答题时，一定要过一遍整份考题，因为题目的难度不一定是递增的 —— 要知道我 22 年国赛看见全卷最简单的题在最后、分值最高、还没时间做有多绝望

标准库

学标准库之前，首先还得会 Python 的一些基础数据类型：str、list、tuple、dict、set

还有文件相关的操作，填空题可能会碰到需要读取 .txt 的题目，运气不好的话碰到超长文本的是复制不了的 (超出剪切板长度限制)

而且对于类和实例的认识是越深越好 (如类似 __call__ 这种名字的类方法)，这有利于你直接阅读源代码，提高对标准库的认知

笔记：Github - py 编程基础.docx

网课：【Python教程】《零基础入门学习Python》最新版

tips：

• 学好迭代器 (包括生成器) 的概念和用法，迭代器的内存占用远远小于 list 等容器，可以大幅度提升性能
• 代码越多越容易出错，利用标准库的函数简化你的代码
• Python 的 for、while 效率低下，尽可能利用标准库的函数规避这些循环
• 避坑 statistics 库，底层代码都是 Python 实现的，效率上求平均不如 sum，中位数和 sorted 差不多，众数和 Counter 差不多

如果不知道以下的这些代码怎么用，可以在我的主页搜索相关代码，就可以看到相应的例题

二分 bisect

对于有序数列 (也可以是有 __lt__ 方法的对象)，二分法查找的速度会快很多

复数 cmath

cmath 库是复数运算库，在蓝桥杯比赛里面很实用

蓝桥杯经常出现一些 x-y 坐标系求两点间距离、角度的题，利用复数的模、相角求解可以简化代码和提高运算速度

容器 collections

Counter 可快速统计序列 (如字符串) 中的元素，而 deque 优化了队列端点的相关操作 (还可以自动限定长度)

拷贝 copy

主要是 deepcopy 比较有用，特别是对于维度大于 1 的 list、多重 dict 的 copy

日期 datetime

蓝桥杯有时会有一些关于日期的题，这个库配合 try - except 语句可以判断某个日期的合法性

两个 datetime 实例 (日期) 相减可以得到 timedelta 实例 (时间差)

函数 functools

lru_cache 用于记忆化 DFS 时，可以自动存储函数在不同参数下的运行结果，效率比自己写的 dict 快很多

堆 heapq

堆在解决“前 n 大”、“前 n 小”的问题上有很高的效率 

这个库只提供了小根堆的函数 (大根堆都是隐藏函数)，要使用大根堆的话对所有元素取负就行了

heapq 不仅可以针对数值类型，还可以用于有 __lt__ 方法的自定义类

迭代 itertools

迭代工具库封装了一些迭代操作，避免使用 Python 的 for 循环可以大大加速

实数 math

开方的速度：math.isqrt 函数 (取整) > math.sqrt 函数 > 运算符

求幂的速度：

• 取整：运算符 > pow 函数 > int(math.pow) > 自编二分快速幂 (无取模)
• 无取整：math.pow > 运算符 > pow 函数 > 自编二分快速幂 (无取模)
• 取模：pow 函数 > 自编二分快速幂

当用到取模的幂运算时，只有内置的 pow 函数提供了 “mod” 参数，math.pow 则没有

其中的 lcm 只有在 Python 3.9.0 以上才可以用，而 gcd 的用法也在 Python 3.9.0 更新为 gcd(*int)，可以求解多个整数的最大公约数。准备一个 Python 3.9.0 可以在填空题省下不少功夫

正则 re

我觉得这是个必学的库，在字符串的处理上有很高的效率

会这个的话考试碰上乱杀 (比如 22 年国赛的内存管理)，不会的话等着被乱杀

时间 time

经过 24 年省赛，发现 time 库还是有必要学的

时间元组的相关内容不用背，了解就行，help(time.struct_time) 和 help(time.strptime) 可以查

刷题网站

经过 2022 的省赛国赛，还是得说：要相信 Python 暴力算法的力量

在刷题的时候，要把有价值的题目记录下来 (e.g. 写博客)，方便日后复习

如果没时间记录的话，可以跟着我的 数据结构与算法专栏 练习、复习

蓝桥杯练习系统

网站链接：http://lx.lanqiao.cn/problemsets.page

“基础练习”里面虽然都是无脑题，但是还是得刷一下的，主要是了解蓝桥杯的测评方法

然后刷题以“历届试题”为主，但是这份题不太全面，建议在 CSDN 上找别人的题解跟着练

我自己在准备蓝桥杯的时候也写了不少题解，可以看我的专栏：数据结构与算法专栏

力扣

网站链接：https://leetcode.cn/problemset/all

力扣的题型和蓝桥杯真题的题型很不一样 (主刷力扣 = 完蛋)，但是力扣有很多的优点：

• 测评透明度高：哪个样例没通过可以看得清清楚楚，会提升你对特例的认知
• 性能排名：力扣会把你的代码性能和其它用户做比较，可以提升代码性能优化能力
• 题解全面：评论区有官方、民间题解，有多个解法的性能比较

我写的题集涉及到了较多的数据结构，这些在蓝桥杯测评系统、C 语言网是学不到的

有些题目比较简单，可以选择性地刷一些：LeetCode：算法面试题汇总

C 语言网

网站链接：https://www.dotcpp.com/oj/lanqiao/

C 语言网的题集收录了蓝桥杯的考试真题，而且比较全面，强力推荐

但是 C 语言网 Python 版本比较低 (3.8 以下)，不支持 math 库的一些函数 (如 isqrt)

函数模板

考试是不能带模板的，而且绝大多数时候都是不能直接套用的 (需要根据题目微改)，所以建议理解构造思路，自己多默写 (标 * 的表示重要性较低)

排列组合

字典序算法

以 [8, 3, 7, 6, 5, 4, 2, 1] 为例，这个函数完成的工作就是：

• 从右到左开始查找，因为 3 < 右边第一个数，所以记 3 的索引为 left
• 从右到左开始查找比 3 大的数，得到 4 的索引记为 right
• 交换 left 和 right 对应的数，此时序列变为 [8, 4, 7, 6, 5, 3, 2, 1]
• 可以看到 left 右侧全是逆序的 (即 4 的右侧)，所以逆转 seq[left + 1: ] 得到 [8, 4, 1, 2, 3, 5, 6, 7]

def next_perm(seq):
    """ 找到下个字典序
        e.g.: 8 3 7 6 5 4 2 1
                |       |    """
    n = len(seq)
    filt1 = lambda i: seq[i] >= seq[i + 1]
    try:
        l = next(it.dropwhile(filt1, range(n - 2, -1, -1)))
        # 找到交换位
        filt2 = lambda r: seq[l] >= seq[r]
        r = next(it.dropwhile(filt2, range(n - 1, l, -1)))
        seq[l], seq[r] = seq[r], seq[l]
        # 逆转逆序区
        seq[l + 1:] = seq[-1:l:-1]
        return seq
    except StopIteration:
        return None

数论

前 n 项平方和：

最小公倍数：

费马小定理： (a, p 互质，p 为质数)

乘法逆元： (a, p 互质)

裴蜀定理：

大于 3 的质数可被表示成 

质数筛法

网上比较推荐的算法是欧拉筛 (线性复杂度，无重复枚举) 和埃氏筛 (有重复枚举)，但是在 Python 代码中，代码较为简单的埃氏筛有更高的效率

def prime_filter(n):
    """ 质数筛选 (埃氏筛法)
        :return: 质数标志
        :example:
        >>> is_prime = prime_filter(10000)
        >>> sum(is_prime[2:])
        1229"""
    is_prime = [True] * (n + 1)
    # 枚举 [2, sqrt(n)]
    for i in filter(is_prime.__getitem__, range(2, math.isqrt(n) + 1)):
        for c in range(i ** 2, n + 1, i):
            is_prime[c] = False
    return is_prime

质因数分解

试除法是最基本的分解方法，在 Python 中 Pollard rho 算法对 7e5 以上的大数分解更快：大数的质因数分解 Python

def try_div(n):
    """ 试除法分解"""
    factor = {}
    i, bound = 2, math.isqrt(n)
    while i <= bound:
        if n % i == 0:
            # 计数 + 整除
            cnt = 1
            n //= i
            while n % i == 0:
                cnt += 1
                n //= i
            # 记录幂次, 更新边界
            factor[i] = cnt
            bound = math.isqrt(n)
        i += 1
    if n > 1: factor[n] = 1
    return factor

所有因数

def all_factor(n):
    """ 所有因数"""
    prime = try_div(n)
    factor = [1]
    for i in prime:
        tmp = []
        for p in map(i.__pow__, range(1, prime[i] + 1)):
            tmp += [p * j for j in factor]
        factor += tmp
    return factor

中国剩余定理 *

求满足以下条件的数 (其中  为质数)：

 可被除了  以外的模数整除，根据费马小定理 ，有以下推导：

 可被除了  以外的模数整除，同时满足 

 可看作一个余数单元， 即可满足上述不等式组的第 i 个条件 ，而不增加其它模数下的余数

将每个余数单元乘以对应的余数累加起来，便可得到满足条件的数的余数项：

def rem_theorem(mods, rems, lcm_fcn=math.prod):
    """ 中国剩余定理
        :param mods: 模数集
        :param rems: 余数集
        :param lcm_fcn: 最小公倍数的求解函数 (模数集全为质数时使用 math.prod)
        :return: lcm, 余数项"""
    lcm = lcm_fcn(mods)
    # 费马小定理求逆元, 要求 a,p 互质
    inv = lambda a, p: pow(a, p - 2, p)
    result = 0
    for p, r in zip(mods, rems):
        a = lcm // p
        result += r * a * inv(a, p)
    return lcm, result % lcm

在用这个函数的时候一定要注意模数集的规模，因为是累乘所以数位会暴增，这会大幅度影响运行耗时

字符串

最长回文子串

Manacher 算法用于求解最长回文子串问题，但其中有个点比较难记忆，在此引用一个示例辅助

对于字符串 s="babba"，先扩充为 s="^#b#a#b#b#a#$"，并创建以下变量：

• 数组 p：以 p[i] 表示对应位置字符的“臂长”，s[i - p[i]: i + p[i] + 1] 范围内的字符串为回文串
• 指针 center, border：分别表示回文串的中心、右端点，总是表示最靠右的回文串

现给出两个示例，求解 p[10] 的初始值 (紫色格子)，s 中的加深部分即为 center, border 所表示的回文串 (记为 sub)

因为回文串的对称性质，p[10] 可以根据 p[4] = 3 进行初始化：

• 示例 1：由于 10 + p[4] > border，所以 p[10] = min(p[4], border - 10)
• 示例 2：由于 10 + p[4] ≤ border，所以 p[10] = p[4]，等价于 p[10] = min(p[4], border - 10)

得到 p[10] 的初始值之后，利用中心扩展法即可得到 p[10] 的最终值，结合 center, border 标记的更新即可写完 Manacher 算法

def manacher(s):
    """ 最长回文子串"""
    s = "#".join(s.join("^$"))
    # 以对应字符为中心 最长回文串的半径
    p = [0] * len(s)
    center, border = 0, 0
    for i in range(1, len(s) - 1):
        # 利用回文串的对称性进行赋值, 利用 min 防止越界
        p[i] = min(p[max(0, 2 * center - i)], max(0, border - i))
        # 中心扩展法
        while s[i - p[i] - 1] == s[i + p[i] + 1]: p[i] += 1
        # 更新回文串中心, 回文串右端点 ("#")
        if i + p[i] > border: center, border = i, i + p[i]
    return max(p)

图论

单源最短路

Dijkstra：使用额外的空间记录“单源最短路”，主体使用 while 循环

def dijkstra(src: int,
             adj: Dict[int, Dict]):
    """ 单源最短路径 (不带负权)
        :param src: 源点
        :param adj: 图的邻接表"""
    n, undone = len(adj), [(0, src)]
    # 单源最短路, 未访问标记
    info = [[float("inf"), True] for _ in range(n)]
    info[src][0] = 0
    while undone:
        # 找到离源点最近的点作为中间点 m
        m = heapq.heappop(undone)[1]
        if info[m][1]:
            info[m][1] = False
            # 更新单源最短路
            for i in filter(lambda j: info[j][1], adj[m]):
                tmp = info[m][0] + adj[m][i]
                if info[i][0] > tmp:
                    info[i][0] = tmp
                    heapq.heappush(undone, (tmp, i))
    return info

SPFA：使用额外的空间记录“单源最短路”、“顶点队列”、“在队标记”、“入队次数”，主体使用 while 循环 (队列非空)

def spfa(src: int,
         adj: Dict[int, Dict]):
    """ 单源最短路径 (带负权)
        :param src: 源点
        :param adj: 图的邻接表"""
    n, undone = len(adj), [(0, src)]
    # 单源最短路, 在队标记, 入队次数
    info = [[float("inf"), False, 0] for _ in range(n)]
    info[src][0] = 0
    while undone:
        # 队列: 弹出中间点
        m = heapq.heappop(undone)[1]
        info[m][1] = False
        # 更新单源最短路
        for i in adj[m]:
            tmp = info[m][0] + adj[m][i]
            if info[i][0] > tmp:
                cnt = info[i][2]
                # 入队: 被更新点
                if not info[i][1]:
                    cnt += 1
                    heapq.heappush(undone, (tmp, i))
                    # 终止: 存在负环
                    if cnt > n: return None
                info[i] = [tmp, True, cnt]
    return info

多源最短路

def floyd(adj: List[List]):
    """ 多源最短路径 (带负权)
        :param adj: 图的邻接矩阵"""
    # import itertools as it
    n = len(adj)
    for m in range(n):
        for i, j in it.combinations(it.chain(range(m), range(m + 1, n)), 2):
            # 有向边写法
            # adj[i][j] = min(adj[i][j], adj[i][m] + adj[m][j])
            # adj[j][i] = min(adj[j][i], adj[j][m] + adj[m][i])
            # 无向边写法
            adj[i][j] = adj[j][i] = min(adj[i][j], adj[i][m] + adj[m][j])

拓扑排序

def topo_sort(in_degree: List[int],
              adj: Dict[int, Dict]):
    """ AOV 网拓扑排序 (最小字典序)
        :param in_degree: 入度表
        :param adj: 图的邻接表"""
    order = []
    undone = [i for i, v in enumerate(in_degree) if v == 0]
    heapq.heapify(undone)
    while undone:
        m = heapq.heappop(undone)
        order.append(m)
        # 删除该结点, 更新入度表
        for i in adj[m]:
            in_degree[i] -= 1
            if in_degree[i] == 0: heapq.heappush(undone, i)
    return order if len(order) == len(in_degree) else None

最小生成树 *

def prim(src: int,
         adj: Dict[int, Dict]):
    """ 最小生成树
        :param src: 源点
        :param adj: 图的邻接表"""
    n, edges = len(adj), []
    # 未完成搜索的边
    undone = [(v, i) for i, v in adj[src].items()]
    heapq.heapify(undone)
    # 和树的最小距离, 最近结点, 未完成标志
    info = [[adj[src].get(i, float("inf")), src, True] for i in range(n)]
    info[src][2] = False
    while undone:
        # 未被选取的顶点中, 离树最近的点
        m = heapq.heappop(undone)[1]
        if info[m][2]:
            info[m][2] = False
            edges.append((info[m][1], m))
            # 更新最近结点
            for i in adj[m]:
                if info[i][0] > adj[m][i]:
                    info[i][:2] = adj[m][i], m
                    heapq.heappush(undone, (adj[m][i], i))
    return edges

并查集

目前我还没有遇见用并查集的题目，有备无患嘛：

• __init__：写入实例属性，_pre 为前驱结点列表 (初始均为自身)，_rank 为结点级别
• find：查找某个结点的根结点
• is_same：检查两个结点是否属于同一棵树
• join：合并两个结点的根结点，根据根结点级别进行合并
• __repr__：规定并查集的字符串形式，调试时使用 

class DisjointSet:
    """ 并查集"""

    def __init__(self, length):
        # 记录前驱结点, 结点级别
        self._pre = list(range(length))
        self._rank = [1] * length

    def find(self, i):
        while self._pre[i] != i:
            i = self._pre[i]
        return i

    def is_same(self, i, j):
        return self.find(i) == self.find(j)

    def join(self, i, j):
        i, j = map(self.find, [i, j])
        # 前驱不同, 需要合并
        if i != j:
            # 访问前驱级别
            rank_i, rank_j = self._rank[i], self._rank[j]
            # 前驱级别相同: 提高一个前驱的级别, 作为根结点
            if rank_i == rank_j:
                self._rank[i] += 1
                self._pre[j] = i
            # 前驱级别不同: 级别高的作为根结点
            else:
                self._pre[j] = i if rank_i > rank_j else j

    def __repr__(self):
        return str(self._pre)