菩提风蓝桥杯打得多了，我越来越确信一件事：这比赛真正考的克制力，是你能不能在该写模板的地方不浪费时间，把省下来的时间留给真正的思考。
每次备赛季，我都能收到一堆“求模板”“求总结”的消息，但真正到赛场上能把模板写对、写稳的人并不多。很多同学不是不会算法，而是基础代码不够熟——输入输出卡壳、边界条件漏判、DFS回溯忘记恢复状态、动态规划数组开小一维……这些失误在平时刷题时毫不起眼，到了比赛就是致命的十几二十分钟。
这篇文章想把我在备赛和实战中反复打磨过的蓝桥杯常用模板一次性整理出来。不会故作高深地堆一堆你根本用不上的高级数据结构，而是聚焦省赛到国赛最常考、最实用的核心模板，从输入输出到排序二分，从DFS/BFS到动态规划，从最短路到并查集，每一份都标清楚适用场景、易错点和优化思路。
如果你正在准备蓝桥杯，或者你只是想系统提升一下竞赛编码的基本功，这篇总结应该能帮你少走很多弯路。我尽量用最直白的话讲清楚每个模板的“为什么”，而不是只给你一个死记硬背的代码片段。
1. 为什么蓝桥杯特别吃“模板基本功”
1.1 比赛节奏决定了你必须“背”代码
蓝桥杯省赛通常会出10道左右的编程题，时间在4小时左右。看起来时间很充裕，但真正做起来你会发现，每道题留给思考的时间远远不够，因为绝大多数代码都需要从头手写，没有代码补全，没有智能提示。
这意味着你每写一个快速幂，都要在白纸上从零开始敲。如果你平时没有把快速幂写熟，而是每次都要临时推导一遍，那一道题光是写这段基础代码就要花掉5到10分钟。整个比赛下来，光是这些“基础模板”的时间损耗可能是一小时以上。
我见过太多同学，算法思路完全正确，最终却因为代码写得太慢、太碎，导致后面的题目没时间调试。这真的很可惜。
1.2 模板质量直接影响调试效率
竞赛圈有个共识：代码写得越规范，调试越快。模板不是说你抄一遍背下来就完事了，而是你要在平时的练习中不断打磨这些模板的写法，让它们稳定、统一、易读。
比如DFS的递归模板，有人喜欢用全局变量记录状态，有人喜欢传参。两种写法都能过，但如果你在一个题目里临时换了风格，就很容易出现状态没恢复好、参数传错的问题。模板的作用就是把你平时反复验证过的、最不容易出错的写法固定下来，形成肌肉记忆。
1.3 模板是“读题→建模→编码”的桥梁
蓝桥杯题目的套路化其实很明显。看到“迷宫最短路”基本就是BFS；看到“连通块数量”大概率是DFS或并查集；看到“最大子段和”就是动态规划；看到“区间查询”要考虑前缀和或线段树。
如果你对这些常用模型的代码模板足够熟悉，读题之后几乎可以立刻确定“这道题应该用什么算法”，然后直接套模板、做适配、提交。反之，如果你还要现场从头想怎么写BFS的队列结构，那你在读题上的优势就被浪费了。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 核心模板逐段拆解（C++版为主，附Java要点）
2.1 输入输出与基础加速模板
很多蓝桥杯考生在输入输出上吃了大亏。C++选手如果直接用cin/cout而不做任何处理，在大数据输入下很容易超时，而Java选手的Scanner在高强度输入下也有巨大性能问题。
C++标准输入输出模板如下：
cpp复制#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
// 业务逻辑
return 0;
}
这里最核心的就是 ios::sync_with_stdio(false); 和 cin.tie(0); 这两行。sync_with_stdio(false) 是关闭C++的iostream与C标准stdio之间的同步，让cin/cout不再与scanf/printf做缓冲同步，从而大幅提升输入输出速度。cin.tie(0) 则是取消cin与cout的绑定，避免每次用cin输入前都强制刷新cout缓冲区。
如果你实在不习惯cin/cout，用printf/scanf也行，但混用的话非常危险，因为你关了同步之后，混用会直接导致数据错位。这是实战中的血泪教训，千万别混用。
Java选手的输入模板建议如下：
java复制import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken());
// ...
}
}
BufferedReader 加 StringTokenizer 的组合，在蓝桥杯Java组中是解决输入瓶颈的经典方案，远快于简单的 Scanner。
2.2 排序模型与自定义比较器
蓝桥杯中，排序通常是解题的第一步，不是核心考点。但恰恰因为它太常用，很多人在排序时出错：数组排序还是结构体排序、升序降序怎么控制、Java中对象排序如何自定义比较器。
C++中普通数组排序：
cpp复制sort(a.begin(), a.end()); // 升序
sort(a.begin(), a.end(), greater<int>()); // 降序
自定义结构体排序时，可以写一个 cmp 函数：
cpp复制struct Node {
int x, y;
};
bool cmp(const Node& a, const Node& b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
sort(nodes, nodes + n, cmp);
在竞赛中使用 cmp 函数是安全性最高的写法，因为lambda表达式在复杂排序条件时虽然很简洁，但一旦写错，编译信息对初学者不太友好。注意 cmp 必须严格满足“严格弱序”的条件，也就是说相等元素必须返回 false。如果一个比较器里写成 a.x <= b.x 这种带等号的写法，在一些编译器实现中会导致未定义行为，这真的是个大坑。
Java中则直接通过 Comparator 接口实现：
java复制Arrays.sort(points, new Comparator<int[]>() {
public int compare(int[] a, int[] b) {
if (a[0] != b[0]) return a[0] - b[0];
return a[1] - b[1];
}
});
需要注意的是，Comparator的返回值如果是负数表示第一个参数排在前面，正数表示第二个参数排在前面。很多初学者会搞反，建议写完之后用一个小样例自测一下顺序。
2.3 二分查找的三个常用模板
二分的代码看似简单，但它是竞赛中非常容易出现死循环或答案错误的地方。蓝桥杯题目里，二分常用于有序数组查找、最值问题的可行性判断等。
最经典的二分查找模板：
cpp复制// 在升序数组中查找第一个 >= target 的位置
int lower_bound_index(int a[], int n, int target) {
int l = 0, r = n;
while (l < r) {
int mid = (l + r) / 2;
if (a[mid] >= target) r = mid;
else l = mid + 1;
}
return l;
}
这个模板使用的是“左闭右开”区间，最终的 l 就是第一个满足条件的位置。如果你要找的是最后一个 <= target 的位置，可以在这个基础上减一，或者改写成另一个模板：
cpp复制// 在升序数组中查找最后一个 <= target 的位置
int upper_bound_index(int a[], int n, int target) {
int l = 0, r = n - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (a[mid] <= target) l = mid + 1;
else r = mid - 1;
}
return r;
}
我在实际练习中的经验是：不要死记硬背三个模板，而是记住两个基础模板——左闭右开求下界、左闭右闭求满足条件的边界，然后进而在中间加判断条件。最怕的是你在比赛时临时推倒重来，把左闭右开和左闭右闭搞混，出现死循环或者越界访问。
这里再强调一点：如果你的数组大小为 n，左闭右开的初始区间应该是 [0, n)，注意右端点是 n 而不是 n-1。很多人的越界问题就出在这里。
2.4 DFS深度优先搜索模板
DFS是蓝桥杯的常客。迷宫寻路、连通块判断、排列组合生成、状态搜索等题目都会用到。DFS的核心是递归和回溯。
经典DFS迷宫模板：
cpp复制int n, m;
char maze[N][N];
bool vis[N][N];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
void dfs(int x, int y) {
if (x < 0 || x >= n || y < 0 || y >= m) return;
if (vis[x][y] || maze[x][y] == '#') return;
vis[x][y] = true;
// 处理当前格子逻辑
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
dfs(nx, ny);
}
}
这个模板覆盖了最核心的三层逻辑：越界和合法性剪枝、访问标记、四方向扩展。很多初学者会忘记写“越界判断”或者“访问标记”，导致程序死循环或者栈溢出。
在这里我特别强调一下：vis[x][y] = true; 的位置非常关键。在连通块问题中，你可以在进入DFS时标记；但在回溯问题中，比如求所有路径，你可能需要在递归返回后恢复状态。这是两种完全不同的使用模式，需要识别清楚。
回溯模板（比如全排列）：
cpp复制vector<int> path;
bool used[N];
void dfs(int depth, int n) {
if (depth == n) {
// 输出path
return;
}
for (int i = 1; i <= n; i++) {
if (used[i]) continue;
used[i] = true;
path.push_back(i);
dfs(depth + 1, n);
path.pop_back();
used[i] = false;
}
}
path.pop_back() 和 used[i] = false; 这两句就是回溯的关键，少了它们结果就会错得离谱。强烈建议在每次递归返回后，立即把状态恢复原样，形成固定的代码习惯，而不要想着“等会一起恢复”。
2.5 BFS广度优先搜索模板
BFS常用于最短路、层次遍历、状态转移等场景。它的模板比DFS更固定，核心是一个队列。
经典BFS模板：
cpp复制queue<pair<int, int>> q;
int dist[N][N];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int bfs(int sx, int sy, int tx, int ty) {
queue<pair<int, int>> q;
memset(dist, -1, sizeof(dist));
dist[sx][sy] = 0;
q.push({sx, sy});
while (!q.empty()) {
auto [x, y] = q.front(); q.pop();
if (x == tx && y == ty) return dist[x][y];
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
if (dist[nx][ny] != -1) continue;
if (maze[nx][ny] == '#') continue;
dist[nx][ny] = dist[x][y] + 1;
q.push({nx, ny});
}
}
return -1;
}
这里有个细节，我用 dist 数组初始化为 -1 来兼顾“是否已访问”和“步数记录”两个信息。第一次发现一个格子时，它的步数就是当前格子的步数加一，因为BFS的层次性保证了这个步数一定是最短步数。
很多同学在这个模板上出过一个问题：把终点判断放在了入队时而不是出队时。虽然通常没问题，但有时候会造成不必要的队列开销。更安全、更规范的做法是出队时判断，这样能保证返回时一定是当前最小步数。
如果状态不是简单的坐标，而是一组变量，比如某个字符串拼图问题，则在判断“是否访问过”时需要用 map 或 set 来记录状态。原理是一样的，只是状态的数据结构更复杂而已。
2.6 动态规划基础模板与常见DP类型速写
动态规划在蓝桥杯中分量很重，几乎每年都有压轴题涉及它的变种。对于需要系统备赛的人来说，不能只会死记代码，而要有自己的DP拆解套路。
我习惯把DP分成三步：
- 定义状态：也就是
dp[i]或者dp[i][j]表示什么含义。 - 写转移方程：找到当前状态是从哪些更小规模的状态转移过来的。
- 确定枚举顺序和边界条件。
实战中，背包DP和线性DP最常考。
01背包模板：
cpp复制int dp[N][M];
int w[N], v[N]; // 重量和价值
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= W; j++) {
if (j < w[i]) dp[i][j] = dp[i - 1][j];
else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i]);
}
}
如果空间受限，可以用滚动数组优化为一维：
cpp复制int dp[M];
for (int i = 1; i <= n; i++) {
for (int j = W; j >= w[i]; j--) {
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
}
}
一维优化的关键是 j 从大到小遍历，这样才能确保在更新 dp[j] 时，dp[j - w[i]] 还是上一层（也就是第 i-1 层）的值。如果 j 从小到大遍历，就会把本轮更新过的值再拿去更新，导致一个物品被重复选取，变成完全背包。这个逻辑一定要理解，不能只死记顺序。
完全背包模板只需要把上面的内层循环改为从小到大：
cpp复制for (int i = 1; i <= n; i++) {
for (int j = w[i]; j <= W; j++) {
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
}
}
这两个模板在笔试中反复出现，用了很多次以后你会发现，只要理解了“当前这一层是否能重复使用”这个概念，根本不需要背代码，临场就能推出来。
最长公共子序列模板：
cpp复制int dp[N][N];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s1[i - 1] == s2[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[0][j] 和 dp[i][0] 都初始化为0，表示空字符串与任意字符串的公共子序列长度为0。在写循环时我习惯直接让下标从1开始，然后用 s1[i-1] 和 s2[j-1] 取字符，避免在循环里做大量 if 判断。
2.7 图论：链式前向星与Dijkstra最短路
蓝桥杯的图论题中，最短路和最小生成树是两位“常客”。对于最短路，Dijkstra 算法是核心，关键是它的优先队列优化写法，也就是常说的 Dijkstra + heap。
如果只用简单的邻接矩阵存图，空间复杂度是 O(n^2)，在节点较多时不够用。更通用的是邻接表。竞赛中最快的存图方式之一是链式前向星，它本质上是静态数组模拟邻接表，写起来比 vector<vector<pair>> 略繁琐，但运行效率更高，而且能够应付很多数据范围偏大的题。
链式前向星的建图和遍历模板如下：
cpp复制const int MAXN = 100005;
const int MAXM = 200005;
struct Edge {
int to, w, next;
} edges[MAXM];
int head[MAXN], idx = 0;
void init(int n) {
memset(head, -1, sizeof(int) * (n + 1));
idx = 0;
}
void addEdge(int u, int v, int w) {
edges[idx].to = v;
edges[idx].w = w;
edges[idx].next = head[u];
head[u] = idx++;
}
遍历时：
cpp复制for (int e = head[u]; e != -1; e = edges[e].next) {
int v = edges[e].to;
int w = edges[e].w;
// 处理边 u -> v，权值为 w
}
很多初学者会问：用 vector 存邻接表不香吗？香，而且更简单。蓝桥杯的大部分题目用 vector 完全足够。如果你刚开始接触图论，不要急着学链式前向星，先用 vector，写熟之后再了解链式前向星的优化意义。比赛中真正重要的不是你用哪种存图方式，而是不要在存图结构上花太多时间去调 bug。
Dijkstra模板（使用优先队列优化）：
cpp复制const int INF = 0x3f3f3f3f;
int dist[MAXN];
void dijkstra(int src, int n) {
memset(dist, 0x3f, sizeof(dist));
dist[src] = 0;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
pq.push({0, src});
while (!pq.empty()) {
auto [d, u] = pq.top(); pq.pop();
if (d != dist[u]) continue; // 过期节点直接跳过
for (int e = head[u]; e != -1; e = edges[e].next) {
int v = edges[e].to;
int w = edges[e].w;
if (dist[u] + w < dist[v]) {
dist[v] = dist[u] + w;
pq.push({dist[v], v});
}
}
}
}
优先队列里 greater<pair<int, int>> 会让最小的元素先弹出。pair的比较默认先比第一个值再比第二个值，所以这里正好先按距离排序，再按节点编号排序。
有一个我自己踩过坑的地方：使用 memset(dist, 0x3f, sizeof(dist)) 会得到一个很大的整数，约等于 1061109567，它并不是真正的无穷大，但只要在 int 范围内能够充当无穷大且保证 dist[u] + w 不会溢出，那就没问题。很多人不知道的是，0x3f 的每个字节都是 0x3f，所以 int 的值是 0x3f3f3f3f。这个数乘以2约等于 2122219134，仍然小于 INT_MAX，所以加边权时不容易溢出。这也是为什么竞赛里大家都爱用 0x3f3f3f3f 而不是 0x7fffffff 的原因。
2.8 数学：快速幂与最大公约数
蓝桥杯经常考到与数学相关的模板题，比如模运算、快速幂、素数判定、最大公约数和最小公倍数。
快速幂模板：
cpp复制long long fastPow(long long a, long long b, long long mod) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
这个模板的原理是“二进制分解指数”。对于任意指数 b，都可以写成若干个2的幂的和，比如 b=13 可以写为 8+4+1，对应的 a^13 = a^8 * a^4 * a^1。代码里每次把 a 自乘相当于计算 a^(2^k)，当 b 的当前最低位为1时，说明需要乘上当前这个 a^(2^k)。这个理解方式比死记代码重要得多，因为很多题目不是直接给你一个快速幂模板题，而是让你在组合数学或者递推中用到快速幂。
模运算有一个非常关键的点：res * a 可能会溢出。如果 mod 是 1e18 级别的数，res 和 a 都是 1e18 以内，相乘就会溢出 long long。遇到这种题，要么把乘法改成“快速乘法”，也就是用类似快速幂的方法来做加法，要么用 __int128。蓝桥杯的常规题目范围一般不会大到需要 __int128，但鉴于不同年份题目风格变化较大，建议掌握快速乘法，模板如下：
cpp复制long long fastMul(long long a, long long b, long long mod) {
long long res = 0;
while (b > 0) {
if (b & 1) res = (res + a) % mod;
a = (a + a) % mod;
b >>= 1;
}
return res;
}
最大公约数模板，我推荐直接用递归写法：
cpp复制int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
最小公倍数则是 a / gcd(a, b) * b，注意先除后乘，避免中间溢出。
2.9 字符串：字符串哈希
蓝桥杯中字符串类的题不少，字符串哈希是一种极其重要的模型。它可以在近似 O(1) 的复杂度下判断两个子串是否相等，常用于模式匹配、回文判断、最长公共子串等问题。
字符串哈希模板：
cpp复制unsigned long long h[N], p[N];
const unsigned long long BASE = 131;
void init_hash(const string& s) {
int n = s.size();
p[0] = 1;
for (int i = 0; i < n; i++) {
p[i + 1] = p[i] * BASE;
h[i + 1] = h[i] * BASE + (unsigned long long)(s[i]);
}
}
// 获取区间 [l, r] 的哈希值，注意这里的 l、r 是 1-based 下标
unsigned long long get_hash(int l, int r) {
return h[r] - h[l - 1] * p[r - l + 1];
}
字符串哈希使用 unsigned long long 的一个好处是，溢出时数字自动取模 2^64，相当于自然取模，省去了手动维护模数的麻烦。同时 BASE = 131 是经验值，冲突率非常低。不过理论上哈希仍然有碰撞风险，如果遇到极端数据，可以把哈希改为双模数或者直接使用字符串结构比对。
这里的核心推导是：假设原字符串是 s[0..n-1]，h[i] 表示前缀 s[0..i-1] 的哈希值。那么如果要取区间 [l, r] 的哈希，就要从 h[r] 里去掉 h[l-1] 中前 l-1 个字符对整个哈希值的影响，也就是乘以 p[r-l+1] 再相减。很多人把这个公式当作死记硬背，但如果你理解了“哈希值是前缀进制的数字表示”，这个公式就会变成一个非常自然的减法。
2.10 数据结构：并查集模板
并查集是蓝桥杯里性价比很高的一个模板。它代码不长，逻辑也相对简单，但可以解决很多连通性问题。
并查集模板：
cpp复制const int MAXN = 100005;
int fa[MAXN];
void init(int n) {
for (int i = 1; i <= n; i++) fa[i] = i;
}
int find(int x) {
return fa[x] == x ? x : fa[x] = find(fa[x]);
}
void unionSet(int x, int y) {
int fx = find(x);
int fy = find(y);
if (fx != fy) fa[fx] = fy;
}
find 中的路径压缩是并查集的核心优化。它在查找的过程中顺手把沿途的所有节点直接挂到根节点上，这样后续查找几乎可以做到 O(1) 的时间复杂度。注意如果只做路径压缩而不按秩合并，并查集的平均复杂度也是非常优秀的，蓝桥杯完全够用。如果你还希望更稳一些，可以在合并时加一个“按大小合并”的策略：
cpp复制int sz[MAXN];
void init(int n) {
for (int i = 1; i <= n; i++) {
fa[i] = i;
sz[i] = 1;
}
}
void unionSet(int x, int y) {
int fx = find(x);
int fy = find(y);
if (fx == fy) return;
if (sz[fx] < sz[fy]) swap(fx, fy);
fa[fy] = fx;
sz[fx] += sz[fy];
}
“按大小合并”让小的树挂到大树上，可以避免树退化成一条链。虽然路径压缩已经能极大优化性能，但加上按大小合并之后，并查集的复杂度理论界更稳定，在大量合并操作时表现更好。
常见变形是在并查集上维护每个集合的大小或到根节点的距离，这种“带权并查集”常用于处理“朋友与敌人”“食物链”等题，尽管代码比基础版稍长，但思路完全一致。
3. 如何把模板转化为赛场的得分能力
3.1 模板不是背出来的，是做出来的
我说句实在话：对着模板抄10遍，不如独立敲3遍。这里的“独立敲”不是指看着模板复制粘贴，而是你给自己出一道题，然后在不参考任何资料的前提下，把对应的算法从头到尾写出来。
我当年准备蓝桥杯的时候，有个特别朴素的方法：把每一类模板题做成卡片，一面写题目描述，另一面写核心算法名称和复杂度。随机抽一张卡片，然后对着白板手写代码，写完再自己出几个测试用例验证。这样做下来，模板的熟练度比单纯看书刷题要高出很多。
3.2 一定要建立自己的“模板库”
每个人写代码的习惯不同，同样的BFS，有人喜欢用 pair<int,int>，有人喜欢写两个并行的数组，还有人喜欢用结构体。这不是谁对谁错的问题，而是你需要在平时选一种自己最习惯、最不易出错的写法，然后固定下来。
我建议你在电脑里单独建一个文件夹，命名为“模板库”，按照“输入输出”“二分”“搜索”“DP”“图论”“数学”“数据结构”等分门别类地存代码。每写一个模板，不要直接复制网上别人的，而是先看懂，再默写一遍，再用自己的话在注释中写清楚“适用场景”和“易错点”。这样这模板才真正是你自己的。
蓝桥杯比赛日当天，虽然不能带纸质资料，但你不能带的是纸，不是记忆。你平时把模板库里的代码写过多少遍，比赛时就能多快地把它默写出来。
3.3 用模板题带动知识串联
蓝桥杯有很多题目并不是单独考察某个算法，而是多个算法组合在一起。比如一道题先需要二分，再需要贪心，最后还要用快速幂。这要求你对模板的熟练程度不止于单个算法，而是要能在头脑中快速进行组合。
我在备赛后期喜欢做一件事：把已学过的所有模板列在一张纸上，然后随机挑两到三个算法，思考它们之间如何配合。比如“并查集+二分”“BFS+字符串哈希”“DFS+动态规划”这类组合，看似奇怪，但在真实竞赛中经常出现。
这种练习的意义在于，当你遇到一道陌生题目时，你脑子里浮现的不再是一个孤立的算法，而是一张可以灵活组合的“模板网”。
4. 常见问题与实战经验记录
4.1 数组越界和初始化问题
很多同学在比赛中最容易踩的坑就是数组越界和初始化错误。比如BFS的 dist 数组没有初始化成 -1，导致访问判断失效；DP数组没有初始化为0，导致结果错误；邻接表的 head 数组忘记初始化为 -1，导致遍历时进入死循环。
一个可靠的习惯是：每写完一个模板，先检查所有数组的初始化语句是否齐全。数组大小至少开到 MAXN + 5，宁可开大一点，不要开小。使用 memset 时，特别注意只对前 n+1 个元素初始化，避免对整个超大数组做无意义的初始化耽误时间。
4.2 边界条件测试是最后一道防线
写完代码并过了样例之后，很多人就直接提交了，这是大忌。竞赛不是只有一个样例，你要自己构造边界用例来测试。比如二分查找时，测试数组长度为1的情况；BFS时，测试起点就是终点的情况；DP时，测试没有物品可选的情况。
我习惯在提交前用三个“万能边界壳”自测：
- 最小数据范围：比如
n=1或n=0时，程序会不会越界或死循环？ - 最大数据范围：会不会超时或者溢出？
- 特殊值：比如负数、0、重复元素，是否符合题目数据约束？
蓝桥杯的样例通常比较弱，有时候样例都过我随便写的代码也能过，但一到评测机就各种 WA。这不是评测机有问题，而是你自己没有把边界想清楚。
4.3 调试技巧：定位问题而不是模糊试错
如果代码运行结果不对，不要着急改代码，更不要“看哪儿像错就改哪儿”。我建议先用二分法定位：在关键位置输出中间变量的值，比如 mid、dist[x][y]、dp[i][j]、find(x) 的结果，逐步缩小问题范围。
对于递归函数，可以在递归入口输出当前参数，确认递归路径是否符合预期。对于图论题，可以写一个简单的数据生成器，输出一张小图，然后人工模拟 Dijkstra 或 DFS 的路径，和程序输出对照。
调试时最怕的是“理论推不出来，就换个写法”。很可能你换的写法引入了新的错误，结果两个 bug 叠加，更不好查。宁可花十分钟把当前代码的每一步输出看明白，也不要盲改。
4.4 做题顺序和时间分配策略
我给大家一个实际建议：拿到题目后，先把所有题快速浏览一遍，标注每道题的难度和预估时间。然后先做有把握的送分题，再做中等题，最后啃难题。不要在一道题上停留超过40分钟，否则后面很可能来不及。
很多同学喜欢从头做到尾，结果第一道题卡了半小时，后面几道简单的题时间不够了。蓝桥杯的分数是按题目分值累加的，并不是按提交顺序加分的。优先保证能拿的分全部拿到，这永远是策略核心。
模板熟练的最大意义就在于此：你不需要在这些基础代码上反复思考，可以把全部精力留给题目本身的逻辑分析。
5. 不同语言选手的模板适配建议
5.1 C++ 组的模板注意事项
C++组是蓝桥杯的大热门。C++模板最重要的是对 STL 的熟悉度。vector、string、map、set、priority_queue、algorithm 头文件下的各类函数，都要达到不用思考就能调用的程度。
同时，注意 C++ 的 auto 和结构化绑定等特性在竞赛环境中通常能得到支持，但在某些老旧评测环境或特殊编译选项下未必完整支持。如果你不确定，就尽量写传统写法，比如 pair<int,int> p = q.front(); 而不是 auto [x,y] = q.front();。尽管蓝桥杯近年支持较新的标准，但“求稳”永远比“耍帅”重要。
5.2 Java 组的模板注意事项
Java组的输入输出比C++麻烦不少，但代码结构更加规范。你要熟练掌握 BufferedReader、String[Tokenizer、](https://taotoken.net?utm_source=hardware)PrintWriter 等的组合使用，避免因为输入输出太慢导致某些大数据题目超时。
Java 的 Arrays.sort 对基本类型数组是升序排列，降序需要手动处理。对 int[] 这类数组，如果你想用自定义降序，需要先把数组转为包装类 Integer[]，再用 Comparator。这个转换过程容易出错，建议提前写一个通用模板，比赛时直接使用。
Java 的 PriorityQueue 默认是最小堆，如果你想使用最大堆，就需要传入 Comparator.reverseOrder()。但蓝桥杯中大量场景反而需要最小堆，比如 Dijkstra，这其实很方便。
5.3 Python 组的模板注意事项
Python组需要注意性能问题。同样的算法，Python往往比C++慢一个量级。有些题目C++能过，Python可能会超时，需要选择更优算法或者尽量使用 PyPy 提交（如果评测环境支持）。
Python的BFS可以用 collections.deque，不要用 list 作为队列，因为 pop(0) 是 O(n) 操作，很容易超时。
python复制from collections import deque
def bfs(start, target):
q = deque([start])
visited = set([start])
steps = 0
while q:
for _ in range(len(q)):
cur = q.popleft()
if cur == target:
return steps
# 扩展逻辑
steps += 1
return -1
很多Python新手会用 list 模拟栈实现DFS，其实没问题，但如果要用DFS最短路或者记录路径，还是建议使用递归并注意递归深度限制，必要时用 sys.setrecursionlimit 提高限制。
6. 从省赛到国赛的进阶模板组合思路
6.1 基础模板先跑通再谈进阶
蓝桥杯省赛的难度通常低于国赛。省赛很多题目，一个基础的BFS或DP模板加上正确的思路就能拿到高分。但国赛的题往往需要在多个模块之间组合，比如先用并查集判断连通性，再用二分查找最优解，最后用快速幂求组合数。
我的建议是：先把本文整理的基础模板理解透彻，在省赛中拿到省奖，再逐步增加状态压缩DP、数位DP、树形DP、网络流等进阶内容。千万不要基础模板还没扎实，就直接去啃难题，这样信心会被打击得很厉害。
6.2 如何扩展自己的模板库
每做完一道有价值的题目，我都会做一个动作：把这道题用到的新模板抽出来，抽象成通用函数，存进模板库。比如我在一道题中学到了“带权并查集维护集合内元素个数”的写法，我就会把它抽象成一份可以重复使用的模板，并配上我自己写的注释。
这样做的好处是，随着刷题量增加，模板库会越来越丰富，而且每个模板都是“带着题目背下来的”，不是干巴巴的代码。
如果你没有养成这个习惯，就会出现一个常见困境：很多算法你都学过，但比赛时就是想不到用它；或者想到了，却写不出来。原因就是你没有把“题目特征”和“算法模板”之间建立条件反射。而模板整理本身，就是建立这种条件反射的最佳训练。
6.3 掌握“复杂度意识”比多背一个模板更重要
最后一个建议，也是我最想说的：模板的本质不是代码，而是“复杂度模型”。面对一道题，你首先要想的不应该是“我有没有背过这个模板”，而应该是“这道题的数据范围支持什么复杂度的算法”。
假设 n <= 10^5，一般只能接受 O(n log n) 或更优的算法；如果 n <= 20，那大概率可以用状态压缩或暴力；如果 n <= 1000，O(n^2) 的DP往往就是正解。
模板库的意义在于，当你根据数据范围确定了“应该用二分”或者“应该用BFS”之后，你能立刻把对应的代码写出来。而不会因为写得太慢，导致明明想到了正解却来不及提交。
比赛就是这样，最终拼的不只是你会不会做，而是你能否在规定时间内把会做的题全部做对。从我自己的参赛和带赛经验来看，模板的熟练掌握，就是“会做的题全拿分”的最强保障。
最后分享一个小习惯：每次比赛或模拟赛结束后，我会把参赛过程中“卡壳”的模板重新敲一遍，并在模板库中记录下这次卡壳的原因。等到下次比赛再遇到同样的场景，大概率不会再卡。这种不断迭代的过程，比单纯多刷十道题帮助大得多。