1. 从竞赛小白到算法模板的“肌肉记忆”如果你正在准备蓝桥杯或者任何类似的算法竞赛看到“代码模板”这几个字是不是感觉像找到了武功秘籍我当年也是这么想的。但踩过无数坑、刷过几百道题、也带过几届学弟学妹后我才真正明白一份好的模板笔记绝不仅仅是把代码抄下来。它应该是你解题思维的“外挂硬盘”是让你在赛场上紧张到大脑空白时手指还能下意识敲出正确代码的“肌肉记忆”。这份笔记就是基于这个目标整理的。它不追求大而全的算法百科全书而是聚焦在蓝桥杯Python组的高频考点和经典题型上。为什么是Python因为在蓝桥杯的赛制下Python的语法简洁、库函数强大能让你把更多精力花在思考算法逻辑本身而不是纠结于语法细节。但这也带来了陷阱——过于依赖库函数可能导致对底层原理生疏在国赛等对性能要求更高的场合吃亏。所以这份“吐血总结”的核心价值在于帮你把有限的备赛时间精准地投入到产出最高的地方。它梳理了从省赛到国赛的常见算法套路、代码实现模板以及那些官方教程里不会写的“踩坑心得”。无论你是刚开始刷题的新手还是想在最后阶段进行冲刺查漏补缺的老手这里面的内容都能直接拿来用或者作为你构建自己知识体系的骨架。2. 核心算法模板与实战精讲算法竞赛尤其是蓝桥杯题目千变万化但核心的算法思想和代码结构是相对固定的。掌握这些模板意味着你拿到题目后能快速识别出它属于哪一类问题并套用经过验证的可靠解法框架大大节省编码和调试时间。2.1 基础数据结构与算法一切的起点这是所有竞赛的基石在蓝桥杯中它们往往不会单独出难题但会作为复杂算法的组成部分频繁出现。列表数组的高效操作Python的列表非常灵活但不当使用会成为性能瓶颈。# 1. 列表推导式 - 快速生成与过滤 # 生成1-10的平方列表 squares [i**2 for i in range(1, 11)] # 生成1-10中偶数的平方列表 even_squares [i**2 for i in range(1, 11) if i % 2 0] # 2. 滑动窗口求最大值/和 - 固定窗口问题的模板 def max_sliding_window(nums, k): 返回nums中每个长度为k的滑动窗口的最大值列表 from collections import deque dq deque() # 双端队列存储下标 res [] for i, num in enumerate(nums): # 维护队列单调递减队头始终是当前窗口最大值的下标 while dq and nums[dq[-1]] num: dq.pop() dq.append(i) # 移除滑出窗口的元素下标 if dq[0] i - k: dq.popleft() # 当窗口形成后记录结果 if i k - 1: res.append(nums[dq[0]]) return res # 实测对于nums [1,3,-1,-3,5,3,6,7], k3输出[3,3,5,5,6,7]注意deque的popleft()是O(1)操作而列表的pop(0)是O(n)在涉及频繁从头部删除时务必使用deque。字典哈希表的妙用字典的核心是O(1)的查找速度常用于计数、快速查找和记忆化。# 1. 计数器Counter - 统计频率的利器 from collections import Counter arr [1, 2, 2, 3, 3, 3] cnt Counter(arr) # Counter({3: 3, 2: 2, 1: 1}) # 获取出现次数最多的元素及其次数 most_common cnt.most_common(1) # [(3, 3)] # 2. 默认字典defaultdict - 避免键不存在的判断 from collections import defaultdict # 将单词按首字母分组 words [“apple”, “bat”, “bar”, “cat”] group defaultdict(list) for w in words: group[w[0]].append(w) # 无需判断 group[w[0]] 是否存在 # group - {‘a’: [‘apple’], ‘b’: [‘bat’, ‘bar’], ‘c’: [‘cat’]} # 3. 两数之和/前缀和互补思想模板 def two_sum(nums, target): 返回和为target的两个数的下标 hash_map {} # 值 - 下标 for i, num in enumerate(nums): complement target - num if complement in hash_map: return [hash_map[complement], i] hash_map[num] i # 先检查再放入避免重复使用同一元素 return []排序与自定义排序排序是许多算法如贪心的第一步。Python的sorted和list.sort()非常强大。# 1. 多关键字排序 tasks [(‘task1’, 3, 10), (‘task2’, 1, 20), (‘task3’, 2, 15)] # 按元组第二项优先级升序第三项耗时降序排序 tasks_sorted sorted(tasks, keylambda x: (x[1], -x[2])) # 2. 对复杂对象排序 class Student: def __init__(self, name, score): self.name name self.score score # 定义富比较方法使对象本身可排序 def __lt__(self, other): # 按分数降序分数相同按名字升序 return (-self.score, self.name) (-other.score, other.name) students [Student(‘Bob’, 88), Student(‘Alice’, 95), Student(‘Cathy’, 88)] students.sort() # 排序后[Alice(95), Bob(88), Cathy(88)]2.2 搜索算法暴力与智慧的平衡蓝桥杯很多题目尤其是填空题和部分编程题数据规模不大搜索是直接有效的解法。深度优先搜索DFS模板DFS适合求解“是否可行”、“所有路径/方案”类问题。# 经典回溯法模板 - 解决排列、组合、子集等问题 def backtrack(path, choices): path: 当前已做出的选择列表 choices: 当前可做的选择列表 if 满足结束条件: 记录结果 (result.append(path[:])) # 注意深拷贝 return for 选择 in choices: if 选择不合法: # 剪枝条件 continue path.append(选择) # 做选择 backtrack(path, 新的choices) # 递归 path.pop() # 撤销选择回溯 # 实例全排列无重复数字 def permute(nums): res [] def backtrack(path, used): if len(path) len(nums): res.append(path[:]) return for i in range(len(nums)): if used[i]: continue # 剪枝数字已使用 used[i] True path.append(nums[i]) backtrack(path, used) path.pop() used[i] False backtrack([], [False]*len(nums)) return res实操心得DFS最怕的就是递归层数过深导致栈溢出。Python默认递归深度约1000层。对于蓝桥杯如果n超过10就要警惕是否需要剪枝或改用BFS/迭代。在回溯时result.append(path[:])中的[:]是关键它创建了path列表的副本。如果直接append(path)后续对path的修改会影响result中已存储的结果这是一个非常隐蔽的bug。广度优先搜索BFS模板BFS适合求解“最短路径”、“最少步骤”类问题它按层搜索找到的第一个解往往就是最优解。from collections import deque def bfs(start, target): 求从start状态到target状态的最少步骤 queue deque([start]) visited set([start]) # 必须记录已访问状态防环 steps 0 # 记录步数 while queue: # 处理当前层的所有节点 for _ in range(len(queue)): cur_state queue.popleft() if cur_state target: return steps # 生成下一层所有可能的状态 for next_state in generate_next_states(cur_state): if next_state not in visited: visited.add(next_state) queue.append(next_state) steps 1 # 一层遍历完步数1 return -1 # 未找到 # 实例在二维网格中找最短路径‘.’可走‘#’障碍 def shortest_path(grid, start, end): if not grid: return -1 rows, cols len(grid), len(grid[0]) directions [(0,1),(0,-1),(1,0),(-1,0)] queue deque([(start[0], start[1])]) visited [[False]*cols for _ in range(rows)] visited[start[0]][start[1]] True distance 0 while queue: for _ in range(len(queue)): x, y queue.popleft() if (x, y) (end[0], end[1]): return distance for dx, dy in directions: nx, ny xdx, ydy if 0nxrows and 0nycols and not visited[nx][ny] and grid[nx][ny]‘.’: visited[nx][ny] True queue.append((nx, ny)) distance 1 return -1踩坑记录BFS中visited集合的加入时机至关重要。必须在节点入队时queue.append就将其标记为已访问而不是在出队时。如果等到出队时才标记可能会导致同一个节点被多次加入队列在状态空间大时引发超时甚至内存溢出。2.3 动态规划DP从暴力到优雅的蜕变动态规划是蓝桥杯的重中之重尤其是国赛。其核心思想是“记住过去减少重复计算”。DP解题四步法模板定义状态dp[i]或dp[i][j]代表什么通常与问题所求直接相关。状态转移方程如何用已知状态推导出未知状态这是DP的核心。初始化最基础、不可再分的情况下的状态值是什么确定遍历顺序确保在计算当前状态时它所依赖的子状态都已经计算好了。经典问题模板示例1. 背包问题0-1背包def knapsack_01(weights, values, capacity): weights:物品重量列表values:价值列表capacity:背包容量 n len(weights) # dp[j] 表示容量为j的背包能装的最大价值 dp [0] * (capacity 1) # 先遍历物品再倒序遍历容量保证每个物品只被放入一次 for i in range(n): for j in range(capacity, weights[i] - 1, -1): # 必须倒序 dp[j] max(dp[j], dp[j - weights[i]] values[i]) return dp[capacity] # 如果要求恰好装满背包的最大价值初始化需改变 # dp [-float(‘inf’)] * (capacity 1) # dp[0] 0 # 只有容量为0的背包在什么都不装时被“恰好装满”2. 最长公共子序列LCSdef longest_common_subsequence(text1, text2): m, n len(text1), len(text2) # dp[i][j] 表示 text1[0:i] 和 text2[0:j] 的LCS长度 dp [[0]*(n1) for _ in range(m1)] for i in range(1, m1): for j in range(1, n1): if text1[i-1] text2[j-1]: dp[i][j] dp[i-1][j-1] 1 else: dp[i][j] max(dp[i-1][j], dp[i][j-1]) # 如果想得到具体的子序列需要反向回溯dp表 return dp[m][n]3. 股票买卖系列状态机DP这是理解状态机DP的绝佳例子。def max_profit(prices): 买卖一次 min_price float(‘inf’) max_profit 0 for price in prices: min_price min(min_price, price) # 记录历史最低价 max_profit max(max_profit, price - min_price) # 今天卖出的最大利润 return max_profit def max_profit_unlimited(prices): 买卖无限次贪心即可所有上涨交易日都买卖 profit 0 for i in range(1, len(prices)): if prices[i] prices[i-1]: profit prices[i] - prices[i-1] return profit def max_profit_with_fee(prices, fee): 买卖无限次但有手续费 # dp[i][0]: 第i天结束时不持有股票的最大利润 # dp[i][1]: 第i天结束时持有股票的最大利润 n len(prices) dp [[0, 0] for _ in range(n)] dp[0][1] -prices[0] # 第一天就买入 for i in range(1, n): # 今天不持有昨天就不持有或者昨天持有今天卖出需手续费 dp[i][0] max(dp[i-1][0], dp[i-1][1] prices[i] - fee) # 今天持有昨天就持有或者昨天不持有今天买入 dp[i][1] max(dp[i-1][1], dp[i-1][0] - prices[i]) return dp[n-1][0] # 最后一天不持有股票利润最大深度解析动态规划最难的不是写代码而是定义状态和找出转移方程。一个实用的技巧是先尝试用递归记忆化搜索的方式思考。比如想求dp[i]就假设所有j i的dp[j]都已知然后思考dp[i]怎么由它们得到。这种方式更符合直觉写出来后再优化成递推形式。对于复杂的DP在代码开头用注释清晰地写出状态定义能极大避免思路混乱。2.4 图论算法连接与路径的艺术虽然蓝桥杯对复杂图论考察不多但基础的并查集、最小生成树和最短路径必须掌握。并查集Union-Find模板用于处理动态连通性问题如“判断两个元素是否属于同一集合”、“合并两个集合”。class UnionFind: def __init__(self, n): self.parent list(range(n)) # 初始化每个元素的父节点是自己 self.rank [0] * n # 按秩合并优化树高 self.count n # 连通分量个数 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和y所在的集合 root_x, root_y self.find(x), self.find(y) if root_x root_y: return False # 已在同一集合无需合并 # 按秩合并将矮树接到高树下 if self.rank[root_x] self.rank[root_y]: self.parent[root_x] root_y elif self.rank[root_x] self.rank[root_y]: self.parent[root_y] root_x else: self.parent[root_y] root_x self.rank[root_x] 1 self.count - 1 return True def connected(self, x, y): return self.find(x) self.find(y)注意事项并查集的find操作中的路径压缩是保证接近O(1)时间复杂度的关键。union操作中的按秩合并rank是为了避免树退化成链表。在蓝桥杯比赛中如果题目没有特殊说明使用这个带路径压缩和按秩合并的模板就足够了。最短路径 - Dijkstra算法模板适用于边权非负的图求单源最短路径。import heapq def dijkstra(graph, start): graph: 邻接表graph[u] [(v, weight), ...] start: 起点 返回: dist数组dist[i]表示从start到i的最短距离 n len(graph) dist [float(‘inf’)] * n dist[start] 0 # 优先队列 (当前距离, 节点) pq [(0, start)] while pq: cur_dist, u heapq.heappop(pq) # 如果当前弹出的距离大于记录的距离说明是旧数据跳过 if cur_dist dist[u]: continue for v, w in graph[u]: new_dist cur_dist w if new_dist dist[v]: dist[v] new_dist heapq.heappush(pq, (new_dist, v)) return dist核心要点Dijkstra算法不能处理负权边。因为其基于贪心策略认为当前从队列中弹出的节点其最短距离已经确定。如果存在负权边这个“确定”性就会被破坏。代码中if cur_dist dist[u]: continue这行是性能优化关键它过滤掉了优先队列中的过期数据同一个节点可能被多次加入队列但只有距离最小的那次是有效的。3. 蓝桥杯特色题型与“骚操作”模板除了通用算法蓝桥杯还有一些自己偏爱的题型和考察点掌握这些能让你事半功倍。3.1 日期与时间处理日期题几乎是每年必考。Python的datetime模块是神器但有时需要自己计算。import datetime from datetime import timedelta # 1. 基本日期计算 def date_calc(): # 构造日期 d datetime.date(2023, 4, 1) # 加减天数 d_next d timedelta(days10) d_prev d - timedelta(weeks2) # 计算差值 diff d_next - d_prev # 返回 timedelta 对象 print(diff.days) # 获取天数差 # 2. 判断闰年、月份天数 def is_leap_year(year): return (year % 4 0 and year % 100 ! 0) or (year % 400 0) def days_in_month(year, month): if month in [1,3,5,7,8,10,12]: return 31 elif month in [4,6,9,11]: return 30 else: # 2月 return 29 if is_leap_year(year) else 28 # 3. 快速计算星期几 - 基姆拉尔森计算公式 def day_of_week(year, month, day): 返回0-60代表星期一...6代表星期日 if month 3: month 12 year - 1 return (day 2*month 3*(month1)//5 year year//4 - year//100 year//400) % 7 # 示例2023年4月1日是星期几 day_of_week(2023, 4, 1) 返回 5即星期六3.2 数论与组合数学蓝桥杯填空题酷爱数论。以下模板必须熟记。# 1. 最大公约数(GCD)与最小公倍数(LCM) - 欧几里得算法 def gcd(a, b): while b: a, b b, a % b return a def lcm(a, b): return a // gcd(a, b) * b # 先除后乘防止溢出 # 2. 质数判断与筛法 def is_prime(n): if n 2: return False if n 2: return True if n % 2 0: return False i 3 while i * i n: # 只需检查到 sqrt(n) if n % i 0: return False i 2 return True # 埃拉托斯特尼筛法 - 快速得到范围内所有质数 def sieve_of_eratosthenes(n): is_prime [True] * (n1) is_prime[0] is_prime[1] False for i in range(2, int(n**0.5)1): if is_prime[i]: # 从i*i开始标记因为i*(i-1)已被更小的质数标记过 for j in range(i*i, n1, i): is_prime[j] False return [i for i in range(2, n1) if is_prime[i]] # 3. 快速幂 - 计算 a^b % mod def fast_pow(a, b, modNone): res 1 while b 0: if b 1: # b是奇数 res res * a if mod is not None: res % mod a a * a if mod is not None: a % mod b 1 # b // 2 return res if mod is None else res % mod3.3 输入输出与性能优化竞赛中错误的IO方式可能导致超时尤其是Python。高效输入模板import sys # 方法一sys.stdin.read() 一次性读取所有内容适用于数据量巨大时 data sys.stdin.read().split() # 按空白字符分割成列表 # 此时 data 是一个字符串列表需要自己转换类型 # n int(data[0]); arr list(map(int, data[1:1n])) # 方法二sys.stdin.readline() 逐行读取最常用 def fast_input(): return sys.stdin.readline().strip() # 去掉末尾换行符 # 使用示例 n int(fast_input()) arr list(map(int, fast_input().split())) # 对于多行输入可以用列表推导式 matrix [list(map(int, fast_input().split())) for _ in range(n)]递归深度与栈溢出Python默认递归深度有限约1000。对于深度可能很大的DFS有两种解决方案修改递归深度限制不推荐在竞赛中作为首选import sys sys.setrecursionlimit(1000000) # 设置为一百万用栈模拟递归推荐将递归函数手动改写成迭代形式用list作为栈来管理状态。这虽然代码复杂些但更安全也是理解递归本质的好方法。列表与字符串操作的性能陷阱字符串拼接避免在循环中使用s ‘a’因为字符串不可变每次拼接都会生成新对象。应使用列表收集最后用’’.join(list)。# 慢 result “” for i in range(10000): result str(i) # 快 parts [] for i in range(10000): parts.append(str(i)) result “”.join(parts)频繁在列表头部插入/删除使用collections.deque。4. 备赛策略与考场实战技巧掌握了算法和模板还需要正确的策略才能将其转化为分数。4.1 不同题型的应对策略蓝桥杯的题目通常分为结果填空题、程序设计题含代码补全和编程大题。结果填空题特点只提交一个最终答案数字或字符串不提交代码。策略这是“送分题”但必须保证100%正确。因为错了就是零分。方法暴力枚举如果数据范围小比如n20写一个简单的循环或DFS暴力求解让计算机替你算。这是最可靠的方法。本地验证用不同的思路或小规模数据验证你的程序输出。例如你可以先写程序算出n5时的答案然后手算或换一种方法验证n5的结果是否正确再让程序去算n100的情况。小心边界特别注意0、1、最大值、最小值等边界情况。程序设计题 编程大题特点提交完整代码系统用多个测试用例评判。策略部分分是关键。确保拿到基础分再争取满分。步骤第一步仔细读题。至少读两遍用笔划出数据范围、输入输出格式、特殊要求如“结果对1000000007取模”。第二步设计算法。根据数据范围选择算法。一个粗略的参考n ≤ 20: 指数级可暴力搜索DFS、状态压缩。n ≤ 100: O(n³) 动态规划、Floyd算法。n ≤ 1000: O(n²) 动态规划、枚举。n ≤ 10^5: O(n log n) 排序、贪心、二分、优先队列。n ≤ 10^6: O(n) 或 O(n log n)必须用高效算法。第三步编写代码。使用清晰的变量名关键步骤加注释。先写输入输出框架确保能正确读入样例。第四步测试与调试。用样例测试这是最基本的。设计边界测试输入为空、单个元素、最大值、最小值。设计随机数据对拍适用于复杂问题写一个绝对正确但很慢的暴力程序brute_force.py和你的优化程序solve.py用同样的随机数据跑比较结果是否一致。这是发现逻辑错误的神器。4.2 考场时间分配与心态管理一场比赛4小时时间非常紧张。前1小时快速通读所有题目按自己的熟悉程度和题目难度进行排序。先做所有结果填空题确保这些“死分”拿到手。遇到一时没思路的填空先标记不要死磕。中间2小时主攻编程大题中看起来最可做的2-3道。采用“先保证部分分再优化”的策略。比如一道题先写一个能过30%数据的小规模暴力解法提交拿到部分分再思考优化方案。最后1小时回头解决标记的填空题检查已做编程题的边界情况。最后15分钟停止写新代码全力检查已做题目文件名、类名、函数名是否正确结果填空题的答案是否抄对了位置心态调整遇到难题很正常。蓝桥杯总有一两道题是拉开差距的可能你完全没思路。这时要果断放弃把时间投入到有把握拿分的题目上。得分的边际效用是递减的从0分到30分很容易从90分到100分可能要多花1小时。编译器是你的朋友。充分利用IDE的调试功能如VSCode、PyCharm的断点、变量监视但比赛环境可能只有基础编辑器所以要练习用print大法调试输出关键变量中间值。带好补给巧克力、红牛等保持大脑血糖和精力。4.3 常见“坑点”速查与应对以下是我和许多选手血泪教训的总结坑点类别具体表现应对策略整数溢出Python本身大整数无忧但结果要求取模时必须在每次加法、乘法后立即取模否则中间结果可能巨大导致超时甚至错误。ans (ans x) % MOD浮点数精度判断浮点数相等不用a b用abs(a-b) 1e-9。涉及浮点数二分时循环条件用for _ in range(100)代替while r-l eps更稳定。定义eps 1e-9递归爆栈DFS时系统报错RecursionError。1. 改用迭代栈。2. 检查剪枝是否充分。3. 必要时sys.setrecursionlimit。列表索引越界访问list[-1]或list[len(list)]。在访问前加条件判断if i 0 and i len(list)。深拷贝与浅拷贝回溯或DP时直接append(path)到结果列表导致后续修改影响结果。使用result.append(path[:])或result.append(copy.deepcopy(path))。输入格式陷阱题目说“输入直到文件结束”但你的代码用for line in sys.stdin可能多读一行空行。使用for line in sys.stdin:并判断if not line.strip(): break。输出格式不符多输出空格、换行或者要求输出“Case #1: ”而你忘了。严格按照样例输出格式编写最后复制样例输出和自己的输出对比。全局变量未重置多次调用函数或处理多个测试用例时全局变量/类静态变量保留了上一次的结果。在函数内部初始化变量或将初始化代码放在每次求解的开始。最后再分享一个我自己的习惯建立个人代码片段库。在备赛过程中把像并查集、Dijkstra、快速幂这些经过反复测试、绝对可靠的模板函数单独保存到一个utils.py文件里。比赛时直接复制粘贴这些函数到你的解题代码中能节省大量时间并避免低级错误。这份笔记就可以作为你代码库的起点。但请记住最好的模板是你自己亲手敲过、调试过、理解每一行代码意义的那个版本。