企业官网建设流程全解析

1. 模板这东西，到底该怎么“背”

先说一个可能有点反常识的结论：蓝桥杯这种算法竞赛，真正考的不是你会不会背模板，而是你在考场上能不能“认出”这道题该用哪个模板，以及能不能在五分钟内把模板改对、改完、调通。

我最早打蓝桥杯的时候，也干过那种蠢事——把一整本《算法竞赛入门经典》当小说啃，把树状数组、线段树、网络流的代码抄在笔记本上，背得滚瓜烂熟。结果一到省赛，第一题签到题用了二十分钟，第三题本来该用前缀和，我想了十分钟才反应过来。回头复盘才发现，模板背熟了不等于会用，会用不等于用得上，这中间隔着的就是对题型的敏感度和对模板内部原理的理解。

所以后来我换了个思路：把模板当成“武器库”，每个武器旁边标注清楚三样东西——适用场景、时间复杂度、容易踩的坑。这样一来，考场上看到题目，第一反应不是“我背过什么”，而是“这道题属于哪种模型”，然后再从记忆里把对应的模板拽出来。

这篇文章要做的，就是把我整理了大半年、经过多次模拟赛和真题检验的蓝桥杯算法竞赛模板体系完整拆给你看。我不打算给你甩一堆网上复制来的代码，而是告诉你每个模板为什么这么写、哪里能改、哪里不能动、考场上怎么快速调用。这件事做扎实了，省赛拿奖是水到渠成的事。

这套模板体系我用的是 C++ 主力、Python 辅助的组合。原因很简单：蓝桥杯C++组的评测环境对 STL 支持很完善，而且 C++ 在复杂数据结构和高效计算上有天然优势。如果你的主语言是 Java 或者 Python，后面我会在关键模板里给出对应实现思路，但核心思想是一致的——模板要短、要稳、要快。

另外说一句，别看到“模板”两个字就觉得是投机取巧。竞赛模板的本质是把那些经过千锤百炼的经典实现固化下来，省去考场上重新推导的时间。这和我们写业务代码用框架是一个道理，关键是你得知道框架底层发生了什么，否则出了问题你连 debug 都不知道从哪下手。

2. 蓝桥杯赛制与考点分布，决定你要准备哪些模板

2.1 省赛和国赛的题型差异

蓝桥杯省赛一般是十道题左右，分填空题和编程大题两类。填空题考察的是手算能力和基础算法的灵活运用，不需要提交代码，只填结果；编程题则是标准的输入输出评测，按测试点给分，过了多少给多少。

这里有个关键信息：蓝桥杯的评测方式不像 ACM 那样严格，它部分测试点给分，也就是说你写个暴力解法，能过几个小数据点就能拿几分。这个赛制特点直接决定了我们的模板策略——先保证暴力能写对，再追求正解能写出。

省赛的难度梯度大致是这样：前两三道是签到题，熟悉输入输出和基础语法就能过；中间几道涉及排序、查找、字符串处理、简单模拟；最后两三道开始上难度，常见的是动态规划、图论搜索、数论、数据结构综合应用。

国赛相比省赛，题目数量差不多，但是难度整体上了一个台阶，尤其是最后几道题，经常是省赛压轴题的难度起步。到了国赛阶段，树状数组、线段树、树形DP这类中级数据结构就变成了常态工具，不是偶尔考一考，而是基本盘。

2.2 高频考点与模板映射关系

我统计了最近几年蓝桥杯省赛和国赛的真题，排除掉每年必有的签到题和模拟题之后，剩下真正有区分度的题目，考点分布大概是这样：

• 前缀和与差分：出现频率极高，尤其是二维前缀和做矩阵区域求和，一维差分做区间加减，几乎每届都考。
• 二分答案：把最优化问题转化成判定问题的思路，蓝桥杯特别喜欢考，配合贪心或者简单模拟就能出成中等题。
• 动态规划：背包问题、最长上升子序列、区间DP、树形DP，这四类是在蓝桥杯中出现频率最高的DP类型。
• 图论搜索：BFS 求最短路、DFS 做连通性判断和回溯，是省赛的常客，国赛则更偏向 Dijkstra 和拓扑排序。
• 数论基础：最大公约数、快速幂、质数筛、扩展欧几里得，使用场景通常是组合数学类题目的前置条件。
• 并查集：用在连通性判断、最小生成树的 Kruskal 算法、以及一些带关系的集合合并问题里。
• 树状数组和线段树：单点修改区间查询、区间修改区间查询，国赛高频，省赛偶尔出现在压轴题。

这些考点不是说每个都要准备得一样深，但每个都要有至少一个“最顺手”的模板。我在后面的章节里会按优先级给出模板代码和关键说明。

3. 核心模板逐一拆解，代码、原理、坑位一次说透

3.1 快速输入输出模板——所有题的地基

很多人不重视输入输出，觉得 cout 和 cin 够用了。但在蓝桥杯的评测环境下，数据量一旦上了十万级别，cin/cout 不关同步和绑定的话，光输入就能让你超时一两秒。这种分丢得极其冤枉。

我的 C++ 默认模板长这样：

#include <bits/stdc++.h> using namespace std; typedef long long ll; typedef pair<int, int> pii; int main() { ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); // 你的代码写在这里 return 0; }

ios::sync_with_stdio(false)的意思是关掉 C++ 流和 C 标准 I/O 的同步，cin.tie(0)是解除 cin 和 cout 的绑定，这样 cin/cout 就不会每次输出都刷新缓冲区，速度能快一个量级。

如果数据量再大，比如单组数据 100 万个数，我建议直接用自定义快读：

inline int read() { int x = 0, f = 1; char c = getchar(); while (c < '0' || c > '9') { if (c == '-') f = -1; c = getchar(); } while (c >= '0' && c <= '9') { x = x * 10 + (c - '0'); c = getchar(); } return x * f; }

这个函数能处理负整数，原理就是逐字符读入并累加，比scanf还要快一些。注意getchar()读的是单个字符，所以它天然能跳过空格和换行。模板里加上这个，遇到大数据量的题目就不会在输入上栽跟头。

输出方面，如果数据量特别大，建议用printf或者把答案拼成一个大字符串最后一次性输出，避免频繁调用cout。这段经验是我在一次模拟赛中实测出来的：同样的解题逻辑，用快读快写比普通 cin/cout 快了接近三倍。

3.2 二分查找与整数二分——最容易写错的万能工具

二分这东西，看起来简单，写起来翻车率极高。我见过太多人死在while (l < r)、mid要不要加一、返回l还是返回l - 1这种细节上。

整数二分的本质是：在一个单调区间里寻找满足某个性质的第一个位置或最后一个位置。只要抓住这个本质，不管题目怎么变，代码骨架都是一样的。

找第一个满足条件的位置：

int binary_search_first(int l, int r) { while (l < r) { int mid = (l + r) >> 1; if (check(mid)) r = mid; else l = mid + 1; } return l; }

找最后一个满足条件的位置：

int binary_search_last(int l, int r) { while (l < r) { int mid = (l + r + 1) >> 1; if (check(mid)) l = mid; else r = mid - 1; } return l; }

注意第二个模板里的mid = (l + r + 1) >> 1，这个加一是为了防止死循环。当l和r相邻时，如果mid不向上取整，l永远无法前进到r，程序就会死循环。

实数二分稍微不同，通常用迭代次数控制精度：

double binary_search_double(double l, double r) { for (int i = 0; i < 100; i++) { double mid = (l + r) / 2; if (check(mid)) r = mid; else l = mid; } return l; }

为什么用固定迭代次数而不是while (r - l > eps)？因为 eps 设太大会精度不够，设太小可能因为浮点误差导致无限循环。固定迭代 100 次，精度远远超过题目要求，而且绝对不会死循环。

二分的核心难点不在模板本身，而在check函数的写法。check(x)回答的是“在 x 处是否满足条件”，你必须把原问题转化成“前一部分不满足、后一部分满足（或相反）”的单调结构。这个转化思路，建议专门找十来道二分答案的真题练一练，练通了比背一百遍模板都管用。

3.3 前缀和与差分——省赛拿分的性价比之王

前缀和是蓝桥杯里性价比最高的模板，没有之一。它代码不过十行，但是能解决一大类区间求和问题。

一维前缀和：

int n; int a[N], pre[N]; for (int i = 1; i <= n; i++) { pre[i] = pre[i - 1] + a[i]; } // 求 [l, r] 区间的和 int sum = pre[r] - pre[l - 1];

二维前缀和：

int n, m; int a[N][N], pre[N][N]; for (int i = 1; i <= n; i++) { for (int j = 1; j <= m; j++) { pre[i][j] = pre[i - 1][j] + pre[i][j - 1] - pre[i - 1][j - 1] + a[i][j]; } } // 求 (x1, y1) 到 (x2, y2) 矩阵和 int sum = pre[x2][y2] - pre[x1 - 1][y2] - pre[x2][y1 - 1] + pre[x1 - 1][y1 - 1];

二维前缀和的核心是容斥原理——加两个大矩阵，减去两个重叠的边角，再加上被多减的那一小块。这个公式看着容易忘，我建议你亲手画个 3×3 的格子推一遍，之后就不会错了。

差分是前缀和的逆运算，专门用来做区间加同一个数：

int diff[N]; // 给 [l, r] 区间加上 c diff[l] += c; diff[r + 1] -= c; // 操作完后求原数组 for (int i = 1; i <= n; i++) { a[i] = a[i - 1] + diff[i]; }

差分的关键理解是：diff数组记录了相邻两个数之间的变化量，区间加同一个数只会影响两端点的差分值。这个思想在二维差分、树上差分中同样适用，理解了它的本质，后面学树状数组区间修改也会轻松很多。

实用心得：蓝桥杯的二维前缀和题目，经常和矩阵旋转、障碍物跳过这些条件混在一起考，不要死记公式，要能根据题目要求动态调整计算方式。

3.4 并查集——连通性问题的标准答案

并查集是解决“两个点是否连通”“一共有多少个连通块”这类问题的第一选择。代码短，性能高，而且蓝桥杯特别喜欢在稍难的题目里嵌套并查集。

int fa[N], rank[N]; void init(int n) { for (int i = 1; i <= n; i++) { fa[i] = i; rank[i] = 1; } } int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); } void merge(int x, int y) { int fx = find(x), fy = find(y); if (fx == fy) return; if (rank[fx] < rank[fy]) swap(fx, fy); fa[fy] = fx; rank[fx] += rank[fy]; }

find函数里的路径压缩是关键优化，它让每个节点直接指向根节点，后续查找几乎变成 O(1) 级别。按秩合并（rank数组）则是让树的高度保持在对数级别，防止退化。

我见过不少人只用路径压缩不用按秩合并，在数据极限情况下被卡到超时。两个优化都加上，代码不过多三行，但能保证最坏情况下的性能。

并查集的一个常见变种是带权并查集，用来维护“敌人关系”或者“食物链”这类有方向的集合关系。它的核心就是在find的路径压缩过程中同步维护节点到根的距离，这个稍微复杂一点，建议单独找题练熟。

3.5 BFS 和 DFS——搜索题的两种武器

BFS（广度优先搜索）天生适合求最短路、最少步数、分层遍历这类问题，因为它是按层扩散的，第一次到达某个点时的路径一定是最短的。

int dist[N][N]; int dx[] = {0, 0, 1, -1}; int dy[] = {1, -1, 0, 0}; queue<pair<int, int>> q; void bfs(int sx, int sy) { memset(dist, -1, sizeof(dist)); dist[sx][sy] = 0; q.push({sx, sy}); while (!q.empty()) { auto [x, y] = q.front(); q.pop(); for (int i = 0; i < 4; i++) { int nx = x + dx[i], ny = y + dy[i]; if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue; if (dist[nx][ny] != -1) continue; if (grid[nx][ny] == '#') continue; // 障碍物 dist[nx][ny] = dist[x][y] + 1; q.push({nx, ny}); } } }

BFS 模板的几个要点：队列里存坐标，用dist数组同时表示“是否访问过”和“距离”，初始化置为 -1。这样就不用单独维护一个visited数组，少写不少代码。

DFS 通常用于回溯、连通性判断和路径枚举：

void dfs(int x, int y) { if (x < 0 || x >= n || y < 0 || y >= m) return; if (vis[x][y] || grid[x][y] == '#') return; vis[x][y] = true; for (int i = 0; i < 4; i++) { dfs(x + dx[i], y + dy[i]); } }

回溯时要在递归返回前撤销标记：

vis[x][y] = false;

这一个细节必须特别注意。蓝桥杯的回溯类题目，比如全排列、八皇后、数独，都是在 DFS 基础上加了“撤销上一步操作”这一步。忘了撤销标记，几乎必然导致结果错误，而且排查起来非常痛苦，因为有时候对、有时候错，完全没有规律。

BFS 和 DFS 的选择原则：求最短路径用 BFS，找所有可能方案用 DFS。这个原则在我刷过的几百道题里几乎没有例外，可以直接当默认决策规则用。

3.6 树状数组与线段树——国赛难度的守门员

树状数组（Binary Indexed Tree, BIT）是单点修改、区间查询的标准工具，比线段树短得多、快得多，常数也很小。蓝桥杯国赛里经常用它来处理有关前缀和的动态修改查询问题。

int bit[N]; int lowbit(int x) { return x & -x; } void add(int idx, int delta) { while (idx <= n) { bit[idx] += delta; idx += lowbit(idx); } } int query(int idx) { int sum = 0; while (idx > 0) { sum += bit[idx]; idx -= lowbit(idx); } return sum; }

理解树状数组的关键在于lowbit——它返回的是 x 的二进制表示中最低位的 1 所对应的值。add操作要从当前节点一路向上更新所有包含它的父节点，query操作要从当前节点一路向左累加所有覆盖它的区间。这种“某些节点代表一块连续区间”的设计，让前缀和查询和单点更新的复杂度都压缩到了 O(log n)。

树状数组求逆序对是个高频场景，思路是：从左到右遍历数组，每次query(a[i] - 1)得到当前已插入的小于a[i]的数的个数，然后用已插入总数减去它就是逆序对数。先用add(a[i], 1)插入当前数。这个思路虽然简单，但考试时不容易第一时间想到，建议提前在模板旁边写清楚一句话注释。

线段树功能更强大，支持区间修改、区间查询、区间最大值、区间和等，但代码量是树状数组的三到四倍。我的建议是：能不用线段树就不用，先评估树状数组能不能解决，解决不了再上线段树。蓝桥杯国赛的压轴题经常需要线段树，但省赛的大部分题目树状数组就足够应付了。

3.7 动态规划模板框架——状态设计才是真正的技术活

DP 类题目在蓝桥杯中的出题频率极高，但很多人以为 DP 模板就是几个经典模型的代码，其实不是。

背包问题的模板是标准化的，01 背包：

int dp[N]; for (int i = 1; i <= n; i++) { for (int j = m; j >= w[i]; j--) { dp[j] = max(dp[j], dp[j - w[i]] + v[i]); } }

完全背包只需要把内层循环改成从小到大：

for (int j = w[i]; j <= m; j++) { dp[j] = max(dp[j], dp[j - w[i]] + v[i]); }

为什么顺序相反？因为从大到小遍历保证每个物品只取一次，从小到大遍历则让同一物品可以被多次选取。这个解释几乎出现在每一本算法书上，但我还是想用自己的话强调一遍：dp[j] 的更新依赖 dp[j - w[i]]，从大到小会让 dp[j - w[i]] 还是上一轮的结果，从小到大则会让它变成已经被当前物品更新过的结果，从而允许多次选取。

最长上升子序列（LIS）有两个版本，O(n²) 的 DP 和 O(n log n) 的贪心加二分。蓝桥杯数据范围小时用 O(n²) 就够，数据大时得用优化版：

vector<int> piles; for (int x : a) { auto it = lower_bound(piles.begin(), piles.end(), x); if (it == piles.end()) piles.push_back(x); else *it = x; } // piles.size() 就是 LIS 长度

这个方法本质上是在维护一个“递增的尾巴序列”，用二分找到第一个大于等于 x 的位置并替换。理解到这里就够用了，具体的数学证明不是竞赛必需。

树形 DP 是国赛常客，核心是在 DFS 遍历树的过程中做状态转移：

void dfs(int u, int fa) { for (int v : G[u]) { if (v == fa) continue; dfs(v, u); dp[u][0] += max(dp[v][0], dp[v][1]); dp[u][1] += dp[v][0]; // 如果选 u，则不选 v } }

这个模板是“没有上司的舞会”这道经典题的解法，它体现了树形 DP 的核心思想：每个节点的状态由其子节点状态推出，而fa参数用来防止走回头路。熟练这个框架后，树上背包、树的最小支配集等问题也能顺着思路推出来。

DP 的真正难点在于状态设计。我的经验法则是：看到求最优值、计数类、可行性判断类问题，先想状态能不能用“前 i 个元素”或“以 i 结尾”来定义，然后试着写出转移方程，最后再压缩空间。这三个步骤即使最终没想出来，也比直接放弃得强。

4. 模板的组装与实战演练

4.1 从零开始，用模板解一道完整真题

光有模板不够，你还需要掌握“组装”的能力。我拿一道典型的蓝桥杯真题来走一遍完整流程，这道题综合了二分、前缀和和贪心三个模板的配合。

题目大意是：给定一个数组，需要把数组划分成若干个连续子段，每个子段的和不能超过给定上限 S，问最少能分成几段。

第一步拆解：这题直接贪心就能做——从左到右累加，超过上限就开新段。但如果数据量到百万级别，而且要求多次询问不同的 S，贪心每次都要重新扫整个数组，就会超时。

第二步用模板组合：观察到“最少段数”随 S 增大而单调不增，可以用二分答案。这里二分的不是最小段数，而是直接二分每个段的最大值 S，然后对每个 S 用贪心检查最少段数是否不超过给定限制 K。

第三步实现：二分用整数二分模板，检查函数用前缀和做区间和快速判断，检查函数内部跑一遍贪心。

第四步调试：小数据测试几个边界情况，比如 S 小于最大值、S 等于最大值、S 极大时都应该一次性或分段正确。

这道题典型的“模板组合拳”路径：识别单调性是第一步，套用二分是第二步，用前缀和加速检查是第三步。没有模板的话，每个环节都要现场推一遍，至少多花二十分钟；有了模板，整个流程压缩到十分钟以内。

4.2 考场上的模板调用策略

考场上怎么合理调用模板，这里有几个我的实战经验：

第一个经验是先写暴力，再写正解。蓝桥杯部分给分机制意味着暴力解能拿到多数小数据点的分。先把暴力解写出来并运行通过，确保基本分到手，再去优化成正解。

第二个经验是模板代码不追求极简，追求稳。我见过有人为了省代码行数，把并查集内联成三行，结果考试时改错一个变量名，整题崩掉。竞赛模板宁可多写几行注释，也要保证每个变量含义清晰、逻辑完整。

第三个经验是不要试图现场发明模板。考场上你可能会觉得某些题目可以套某个算法，但标准模板写不出来。这时果断放弃，回到暴力解，不要赌现场能不能想出来——想出来的时间成本太高，而且出错概率极大。

第四个经验是给模板设计统一的函数签名。比如所有数据结构模板都用init(n)初始化、add(pos, val)修改、query(l, r)查询，这样在写主逻辑时不需要回忆每个模板的函数名，心智负担小很多。

4.3 敲击键盘之前，先在草稿纸上完成算法设计

我见过太多人在考场上拿到题目就打开代码编辑器，结果边写边想，写到一半发现思路错了，删掉重来。这个习惯非常糟糕。

我的建议是：拿到题目后在草稿纸上标出四个问题——输入规模上限是多少、时间复杂度要求是多少、能用什么算法、边界条件有哪些。

输入规模决定了算法选型：n 在 1000 以内可以随便暴力，n 在 10 万级别需要 O(n) 或 O(n log n)，n 到 100 万基本只有 O(n) 才能稳过。

边界条件则是模板最容易出 Bug 的地方：数组越界、空集合、重复元素、最小值负无穷等等。我每次写代码前都会在草稿纸上标注“测试用例”，包含了最小数据、最大数据、重复数据、极端分布这几类，写完后立刻逐条过一遍。

这个方法把我考场的错误率降低了至少一半。写代码前的两分钟规划，比写完后花二十分钟调试划算得多。

5. 蓝桥杯备战经验与常见坑排查

5.1 数组越界和初始化问题

数组越界是竞赛编程中最常见的 Runtime Error，但很多新手直到考试结束都不知道自己错在哪。

典型场景是二维数组，比如网格题里 DFS 访问grid[x][y]时，x 和 y 没有检查边界，直接访问负索引或者超出数组大小的位置，程序直接崩溃。

解决方式有两个：一是硬编码边界检查，二是把数组开大一点并让索引从 1 开始，留出哨兵边界。我强烈建议在数组定义时统一多开一位，比如int a[N + 10]，这样即使代码里出现+1或-1的偏差也不会立刻越界，排查起来轻松很多。

初始化问题同样高发。memset(dp, 0, sizeof(dp))只能清零，但不能初始化成极大值。要求最大值时初始化为极小值，用memset(dp, 0xc0, sizeof(dp))，表示负无穷；要求最小值时用memset(dp, 0x3f, sizeof(dp))，表示正无穷。这两个十六进制常数的好处是，0x3f3f3f3f做加法不会溢出 int，而且方便肉眼识别。

布尔数组用memset(vis, 0, sizeof(vis))没问题，但注意 Python 里不要直接用numpy的方法来初始化，蓝桥杯官方环境不支持第三方库，老老实实用 list 初始化。

5.2 死循环的隐形元凶

死循环不同于崩溃，程序运行但不结束，大概率是这几个原因：

整数二分模板里mid没有正确向上取整，导致区间无法收缩。这个问题在 3.2 节里已经强调过，这里再重复一次——用mid = (l + r + 1) >> 1的那个模板一定要看清自己的写法是哪个版本。

BFS 或 DFS 中访问标记的时机不对。BFS 中必须在入队时就标记 visited，而不是出队时才标记。如果出队时再标记，同一个节点可能被多个队列路径重复压入，导致队列指数级膨胀，最终超出内存限制或陷入死循环。

递归 DFS 中递归出口条件写得不对，比如边界判断放在了递归函数最前面但漏掉了某些情形。我的经验是：每一个递归函数的第一行，先写最显眼的出口条件，确保第一个分支能正确返回。

还有一个隐蔽的问题：while (!q.empty())中 q 在循环体里被误清空，或者循环条件写了while (1)却忘了在内部做退出判断。这类低级错误一旦出现非常耗时，建议所有循环都明确写出终止条件和计数器，避免依赖隐含条件。

5.3 时间超限的分层排查

时间超限（TLE）是蓝桥杯最常见也最让人头疼的提交结果。我一般按以下顺序排查：

首先看算法复杂度是否匹配输入规模。n 是 100 万用了 O(n²) 的算法，几乎必然超时。如果确认算法没问题，再看常数优化。

常数优化有几个方向：把递归改成迭代、减少不必要的函数调用、用数组代替 STL 容器、尽量用位运算代替乘除法。但对于蓝桥杯得分制，如果你的暴力解法能过一半测试点，其实已经可以接受，不必为了性能硬啃正解。

还有一个被忽略的点：蓝桥杯评测机的性能波动。同一份代码你可能第一次提交超时，第二次就通过了。我的建议是，在时间限制边缘的题目，提交前先优化一下常数，提交两三次对比结果。

5.4 从评测环境反推题目意图

蓝桥杯的评测环境是固定配置，内存限制一般是 256MB 或 512MB，时间限制每道题不同。你可以根据这两个数字反推题目考察的算法。

时间限制在 1 秒以内的题目，原地复杂度的要求很高。n 在 10 万以内的输入规模，O(n²) 算法理论上能过但常数必须小；n 在 50 万以上基本要求 O(n) 或 O(n log n)。

内存限制 256MB 时，动态开一个 10 万 × 10 万的二维数组会立刻超出内存，说明题目必然希望用一维 DP 或者状态压缩，不会让你开这么大的数组。反过来，如果题目允许开二维数组，那状态设计空间就比较充裕，可以放心用 O(n²) 的 DP。

这个“从限制反推解法”的思路，能帮你快速排除不合理的方案，少走弯路。

5.5 模板可扩展：从通用到专属

最后说说模板之外最重要的东西：如何让你的模板从“通用的”变成“专属的”。

通用模板是我在本文中分享的那些经典实现，它们解决的是标准问题。但蓝桥杯真正拉开差距的题目往往不是标准问题的直接套用，而是在标准模板基础上增加条件、修改规则、混合考点。

我的做法是：每做完一道新题，如果发现它是在某个模板上的变形，就把变形方式记录在对应模板旁边。比如“树状数组模板——可以扩展到维护最大值的版本，用 add 改为更新最大值，query 改为求区间最大值”。这样积累到考前，你的模板库就是一本浓缩的错题本和题型字典。

考前一周，把模板库通读一遍，合上电脑，能在纸上把每段模板的关键代码默写出来，就算真正掌握了。考场上你不再是“回忆模板”，而是“输出技能”，这个心态上的差别会直接反映在答题速度和正确率上。

我实际备赛的感受是：模板这个东西，你背一百遍不如亲手敲十遍，你敲十遍不如带进去考场用一次。所以，不要去囤模板，要去用模板。每次模拟赛、每次真题练习，都强迫自己从模板库里调用、修改、组合，等你把常用模板练到不需要思考就能写出来的时候，蓝桥杯中等待你的就不再是“不会做”，而是“怎么做更快”。