每一届蓝桥杯省赛结束之后，都有大量同学来找我聊同一个问题：“真题到底该怎么刷？我现在开始备赛，是先做题库还是先做真题？”我的答案一直没变过：真题永远是效率最高的切入点。
第十六届省赛题目我也在持续整理中，目前已经回收并手推了一部分题，这篇文章先分享整卷结构、已收录题目的解题思路、以及我认为最关键的备赛方法。后面更新的题目我会在文末说明，你可以当作一份“带注释的题解草稿”来看。
1. 第十六届省赛真题的整体盘子：难度、分值、题型三重观察
1.1 为什么蓝桥杯真题是“押题率”最高的资源
先说一个很多新手没意识到的事实：蓝桥杯的出题风格虽然每年都有微调，但核心的考点谱系非常稳定。
我统计了近五年的省赛真题，C/C++ 组和 Java 组的题目分布在“模拟与数学”“搜索与图论”“动态规划与贪心”“字符串与数据结构”“数论与组合计数”这几大板块的比例几乎没有大起大落。这说明什么？说明你只要把真题吃透，就相当于把命题人的题库给“预判”了。
第十六届省赛的整卷延续了这一规律，但有两个明显变化值得关注：
第一，题面变长，场景描述更复杂。往年一道模拟题可能两三行就说清楚规则，今年有几道题花了大段文字去描述“物流路径”“数据清洗”之类的业务背景。这意味着读题能力本身正在成为考察点，而不是单纯的算法能力。
第二，综合性更强。前几年省赛的压轴题常常是“单独的大搜索”或者“明显的状态压缩DP”，今年我看到的题目中有不少是“二分 + 图论”“前缀和 + 思维转化”这类组合型考法。这对只背模板、不理解原理的参赛者是致命的。
1.2 分值分布与答题策略推导
蓝桥杯省赛的题量常规情况下是10道题，其中前几道是填空题（只要结果不要过程），后几道是程序设计题（需要提交完整代码，按测试点给分）。
结合第十六届的情况，我建议的答题时间分配是这样的：
| 题号区间 | 题目类型 | 建议用时 | 策略 |
|---|---|---|---|
| 第1-2题 | 填空题/简单编程 | 20分钟内 | 必须全对，这是保底分 |
| 第3-5题 | 思维+基础算法 | 40-50分钟 | 争取AC 2-3道 |
| 第6-8题 | 中等算法题 | 50-70分钟 | 目标拿部分分，优化测试点覆盖率 |
| 第9-10题 | 压轴题 | 剩余时间 | 宁可暴力拿前30%的分，也别空着 |
很多人有个误区：觉得压轴题写不出来就等于没戏。实际操作中，蓝桥杯是按测试点给分的，压轴题即使只跑过小数据也能拿到可观的分数。我见过的选手中有不少是靠“暴力 + 部分优化”挤进省一的，这绝对是一条值得认真对待的路线。
1.3 “更新中”版本的真题该怎样定位
既然题解还在更新，你手里拿到的可能是一份不完整的题目集。这在备赛阶段反而是好事——你可以先拿已经更新的部分做深度梳理，剩下的保持关注、定期回看。我会在后面的章节详细说如何用这种“半成品资源”做训练，而不是干等完整版。
2. 已收录真题的代码思路与踩坑记录
这里挑几道我已经整理完的题，按“题干压缩 + 思路演进 + 代码骨架 + 踩坑点”的方式呈现。题目描述我会转述核心逻辑，具体的完整原题以官方发布为准。
2.1 填空第一题：进制转换与取模陷阱
这类题基本是老兵新传。第十六届又考了“给定一个进制规则，求某一大数的某一位或者某几位”。表面上是暴力模拟题，实际上考的是进位原理和字符串处理。
我看到这道题的第一反应是：直接按进制换算公式展开，在数组里维护各位数字，然后逐位相加。但真上手就会发现一个隐藏问题：题目给的数据范围可能达到10^1000级别，任何整型类型都存不下，必须用字符串或者数组模拟手算。
我的代码骨架如下：
#include <bits/stdc++.h> using namespace std; int main() { string a, b; cin >> a >> b; // 将字符串转为数组，逆序存储 vector<int> A(a.size()), B(b.size()); for(int i = 0; i < a.size(); i++) A[a.size()-1-i] = a[i]-'0'; for(int i = 0; i < b.size(); i++) B[b.size()-1-i] = b[i]-'0'; // 高精度加法，注意进位 int len = max(a.size(), b.size()) + 1; vector<int> C(len, 0); int carry = 0; for(int i = 0; i < len; i++) { int av = i < A.size() ? A[i] : 0; int bv = i < B.size() ? B[i] : 0; int sum = av + bv + carry; C[i] = sum % 10; carry = sum / 10; } // 去除前导零后输出 int pos = len - 1; while(pos > 0 && C[pos] == 0) pos--; for(int i = pos; i >= 0; i--) cout << C[i]; return 0; }这里的核心坑点有三个：
一个是字符串与数组的下标映射。很多人习惯了从低位到高位存储，结果进位时忘记处理最高位溢出，导致答案少一位。二是输入可能带前导零，我见过有同学直接stoi转成整型，一测大数据直接爆。三是填空题只需要最终答案，所以手算打草稿时也别忘了用程序验算一遍，填空题错了整题零分，比程序题更残酷。
2.2 程序设计题：模拟物流配送的最短时间（BFS 变形）
今年的模拟题比往年“有重工业味”。题干大意是：在一个网格地图上，给定多个配送点和一些障碍物，求从起点出发遍历所有配送点并返回的最短时间。
这道题表面看像旅行商问题，数据范围如果大了确实要状压DP，但第十六届的约束条件给得很仁慈——配送点的数量极少，不超过5个。这种情况下根本不需要想复杂了，直接用 BFS 预处理配送点两两之间的距离，再对配送顺序做全排列暴力求解即可。
这也是我反复强调的一个原则：先看数据范围，再决定算法。
#include <bits/stdc++.h> using namespace std; const int dx[] = {1, -1, 0, 0}; const int dy[] = {0, 0, 1, -1}; int n, m; vector<string> grid; int dist[10][10]; // 配送点之间的距离 struct Node { int x, y; }; int bfs(Node start, Node end) { vector<vector<int>> d(n, vector<int>(m, -1)); queue<Node> q; q.push(start); d[start.x][start.y] = 0; while(!q.empty()) { Node cur = q.front(); q.pop(); if(cur.x == end.x && cur.y == end.y) return d[cur.x][cur.y]; for(int i = 0; i < 4; i++) { int nx = cur.x + dx[i], ny = cur.y + dy[i]; if(nx < 0 || nx >= n || ny < 0 || ny >= m) continue; if(grid[nx][ny] == '#') continue; if(d[nx][ny] != -1) continue; d[nx][ny] = d[cur.x][cur.y] + 1; q.push({nx, ny}); } } return -1; } int main() { // 读入 n, m, grid // 收集起点和配送点位置 vector<Node> sites; // sites[0] 为起点，其余为配送点 int k = sites.size(); for(int i = 0; i < k; i++) for(int j = i+1; j < k; j++) dist[i][j] = dist[j][i] = bfs(sites[i], sites[j]); // 对配送顺序枚举全排列 vector<int> order; for(int i = 1; i < k; i++) order.push_back(i); int ans = INT_MAX; do { int cur = dist[0][order[0]]; for(int i = 0; i+1 < order.size(); i++) cur += dist[order[i]][order[i+1]]; cur += dist[order.back()][0]; ans = min(ans, cur); } while(next_permutation(order.begin(), order.end())); cout << ans << endl; return 0; }这道题最值得说的不是BFS本身，而是状态建模。很多人一看到“多个点 + 最短 + 遍历”就直接去写搜索树上带着“已访问集合”的状态，代码一写就是一百多行，跑起来还超时。其实只要意识到配送点一共就5个，全排列5!=120种顺序，哪怕每个组合都跑一遍BFS都完全来得及。
顺带提一个老生常谈但每年都有人犯的错：next_permutation只能正确枚举升序序列的全排列，如果你没有先把order排序，后面你会漏掉整整一半的排列组合。这个bug隐蔽到什么程度？你测试小样例可能全对，但一提交就WA，而且大概率找不出原因。
2.3 程序设计题：山峰数组专项（单调栈与贡献法）
今年的中等题里有一道让我印象很深，大意是求数组中每个元素“能看见的山峰数量”“能配对的对数”之类的问题。这种题表面是几何感知，实际内核是单调栈 + 贡献法统计。
这类题的核心难点在于：直接枚举每对元素的时间复杂度是 O(n^2)，n若到10^5级别必然超时。解法是利用“单调栈维护右边第一个更高的元素”，把问题转化成栈内统计。
我给一个典型的求“数组中每个元素右侧第一个更高元素下标”的模板：
#include <bits/stdc++.h> using namespace std; vector<int> monotonicStack(const vector<int>& arr) { int n = arr.size(); vector<int> res(n, -1); // 存放右侧第一个更高元素下标 stack<int> st; for(int i = n-1; i >= 0; i--) { while(!st.empty() && arr[st.top()] <= arr[i]) st.pop(); if(!st.empty()) res[i] = st.top(); st.push(i); } return res; }注意这里while循环的条件是<=，代表我们要找的是严格更高的元素。如果你在这里用<，那么相等高度的山峰也会被算进来，导致答案整体偏大——这种bug在逻辑上特别难察觉，因为测试样例不仔细根本看不出来。
如果你想深入理解单调栈的哲学，可以把它想成“每个元素入栈一次、出栈一次”，总复杂度是 O(n)。这个思想在很多与“下一个更大/更小元素”相关的题目里都会用到，而且常常跟计算面积、统计对数、区间最大值等问题交叉出现，是省赛拿奖必须掌握的常规武器。
2.4 压轴题：区间异或统计（前缀异或 + 哈希表）
今年压轴题我看到的回忆版本是一道和异或相关的计数题，约束条件n到10^5，询问区间内满足某异或条件的子区间数量。这道题把我当年第一次见到的时候也卡了很久，它的套路非常经典：前缀异或 + 哈希表的相遇问题。
核心思路是：
把数组转换成前缀异或数组pre[i]，其中pre[0]=0，pre[i]=pre[i-1]^a[i-1]。那么区间[l, r]的异或值就等于pre[r]^pre[l-1]。如果一个区间要满足某个异或值x，那等价于pre[r]^pre[l-1]==x，进一步可以写成pre[l-1]==pre[r]^x。
于是问题从“枚举所有区间”变成了“遍历右端点时，查表看有多少个左端点符合条件”。
#include <bits/stdc++.h> using namespace std; int main() { int n, x; cin >> n >> x; vector<int> a(n); for(int i = 0; i < n; i++) cin >> a[i]; vector<int> pre(n+1, 0); for(int i = 0; i < n; i++) pre[i+1] = pre[i] ^ a[i]; unordered_map<int, int> cnt; cnt[0] = 1; long long ans = 0; for(int i = 1; i <= n; i++) { // 寻找 pre[j] == pre[i] ^ x 的前缀数量 int target = pre[i] ^ x; ans += cnt[target]; cnt[pre[i]]++; } cout << ans << endl; return 0; }这道题看起来短，但含金量非常高。它考的不只是异或运算的性质，更考你是否能敏锐地把“区间异或和”转化成“两个前缀异或值的关系”。如果你对这类转化不熟，即使给你满分模板，你也想不到去用它。
我自己的经验是，对于异或类题目，优先想前缀异或。异或的逆运算就是它自己，这个性质太优雅了，几乎所有区间异或问题都可以从前缀异或入手。
3. 把“半成品真题”变成训练弹药：100天备赛计划
3.1 先做“题型聚类”，不要按题号刷
真题整理版还在更新中，很多人拿到手一不小心就做成“有一道刷一道”，这是效率最低的用法。
我建议你把已经出现的题目先按知识点重新分组：模拟题放一起、搜索题放一起、DP题放一起、数论题放一起。刷的时候不是按顺序做，而是按主题逐个击破。比如今天定主题是“搜索”，就把真题里的搜索题全部挑出来，连同往年类似题，一次性做8-10道。这种聚类刷法能帮你在短时间内形成对某类题的条件反射，效果远好于撒网式刷题。
3.2 黄金三遍刷法：每题至少做三遍
对于真题，我非常推荐“三遍刷法”：
第一遍：拿到题先独立思考半小时，想不出就看题解思路，然后自己动手把代码写出来。重点是搞懂解题逻辑，而不是记住代码。
第二遍：隔3-7天后，把这道题重新做一遍，期间不看任何题解。这一遍的最重要价值是暴露你是否真的掌握了，而不是“看懂了”。
第三遍：冲刺期回看题目列表，只看题干，在脑中快速过一遍思路和复杂度，写不出来的就标记为“需要重点突破”。这一遍用来做查漏补缺，打开率非常低但是提分效率极高。
这个方法看起来占时间，实际上省时间。因为它直接消灭了“刷过等于会了”的假象。
3.3 从真题反推知识点，而不是盲目学
很多备赛的同学最大的问题不是不努力，而是不会规划。今天看一点图论，明天看一点数论，跟刷短视频一样没有章法。
我的建议是：让真题当你的课程大纲。把目前更新的真题逐题摊开，标注每一题背后关联的知识点，然后把它们整理成一张清单。这个清单，比任何一本算法书的前言都更贴合蓝桥杯省赛。清单上出现的知识点优先学透，没有出现的可以暂缓。
举我自己整理的一个例子：第十六届已更新的几道题涉及“高精度”、“BFS/DFS”、“单调栈/单调队列”、“前缀异或与哈希”、“快速幂”。那么我接下来一周的学习重点就定为这五个方向，每个方向找10道题做配套训练。这样一来，每一次刷题都有明确的靶向，就不会出现“什么都会一点但什么都不精”的情况。
3.4 利用“更新中”的边角时间差
题目还在陆续整理，这意味着什么？意味着你可以利用这段时间差，主动去搜索去年或往年同类型题目做预测性训练。比如第十六届的某道题，如果它是BFS+最短路模型的变体，那往年省赛出现的“迷宫最短路”“传送门最短路径”这些题目就更值得做。真题更新一篇，你就补一篇的配套训练，始终保持“真题在更新，功夫在增长”的节奏。
有一种情况你一定会遇到：题目更新之后，你发现自己之前对某道题的理解方向完全错了。这非常正常。不要懊恼，这正是真题集“更新中”这个状态带给你的纠错机会，等到完整版出来再看反而没有这个主动纠偏的过程。
4. 参赛实战中的常见问题与避坑
4.1 填空题到底怎么填？结果精度与格式
填空题只要一个最终数字，过程在考卷上看不到。很多选手并不重视填空题，觉得分值小，其实填空题的正确率往往决定了你省二和省一的差距。
填空题最怕两件事：一是算对了但填错位数，比如题目要求结果取模1e9+7，你填了原始超大数；二是忽略题目给的陷阱条件，比如“数字之间用逗号分隔”这种格式要求。
我建议比赛时每个填空题至少验算两遍。如果时间和环境允许，可以用程序跑一遍，甚至可以用两种不同思路各写一个小脚本，交叉验证结果一致才算过。填空题没有部分分，错一个就是整题归零，多花三分钟验算绝对是稳赚不赔的投入。
4.2 本地能跑、提交就挂：环境差异与未定义行为
这是每年提问区最活跃的一类问题：“我本地明明通过了样例，在OJ上就是WA/RE，为什么？”
原因通常是这几类：
第一，本地编译器版本和OJ环境不一致，某些 C++ 写法是老版本编译器过不了的。比如用了#include <bits/stdc++.h>在某些环境不支持，或者auto推导的行为不同。虽然蓝桥杯的评测环境普遍支持新版编译器，但你不能假设它跟你本地一模一样。
第二，数组越界问题。本地运行时内存可能正好没被破坏，但OJ上栈里下面恰好存了关键变量，就越界出错了。这类问题非常恶心，只能靠养成“所有遍历都带上边界检查”的习惯来规避。
第三，long long溢出。很多选手习惯性用int，但第6题之后的数据范围就已经允许算到10^9了，两个区间长度相乘立刻溢出。今年我就看到不止一个选手在区间计数题里因为int乘法溢出吃大亏。建议：只要可能有乘积的操作，一律用long long或__int128，不要吝啬这么一点内存。
4.3 暴力超时怎么办：部分分策略的精细操作
蓝桥杯给的是部分分，这一点真的是给了选手很大的容错空间。但很多选手却没有利用好。
我的建议是：读每一道题的时候，第一遍先想暴力的做法，并且在草稿纸上写下暴力的时间复杂度；随后看数据范围，计算暴力能覆盖到什么程度。如果题目给了多个子任务，通常小数据范围对应暴力解法，大数据范围对应正解。你至少要写出能通过最小测试点的代码，这是底线。
举个例子，一道题 n=10^5，要求 O(nlogn) 或 O(n)，但你一时想不出正解。此时如果你写的是 O(n^2) 的暴力，很可能一个测试点都过不了；如果你发现可以用“对所有偶数下标单独处理”之类的偏方先骗过部分小数据，那就远远好过空着交白卷。
另外也可以利用“特殊情况”骗分：数据保证全是正整数、保证无重复元素、保证图是树形结构。这类特殊情况往往对应着简单解法，骗到两三个测试点绰绰有余。
4.4 比赛时间分配：前松后紧是大忌
蓝桥杯省赛的时间一般是四五个小时左右。这个时间是够做完的，前提是节奏正确。
我见过最典型的失败案例是：某位同学前两道送分题花了整整一个小时去精雕细琢，导致后面几道中档题没有时间写，压轴题更是看都没看。送分题的意义在于拿保底分，不在于完美优化。别在第一题追求几十毫秒的加速，那是几乎没有意义的行为。
一个可参考的时间轴：
前30分钟：完成前两道送分或填空题，快、稳、准。
第30-90分钟：主攻中间的3-5道题，先把能拿满的分拿完，再回头优化。
第90-150分钟：逐题尝试后面中等偏上的题目，索性别执着于满分，能骗一个测试点是一个。
最后60分钟：全卷复查 + 把还没有任何代码的题至少写个暴力上去。
请记得，编码能力你平时练得再好，上了赛场心态只要不稳，前两道送分题都可能写崩。所以平时模拟就要用多组“有坑样例”来训练心理耐受度。
4.5 代码风格与调试习惯：现场少走弯路
还有两点非常朴素但真实的建议。
第一，变量名尽量见名知意。赛场上一紧张，i, j, k, ans, cnt这类变量是最容易混淆的。尤其是多组数据处理时，循环变量用完忘清零，直接导致连环WA。你可以试试在本地就练习“每组数据处理前先清零变量”的惯性动作。
第二，善用注释做断点。现场遇到逻辑不对，不要只知道一个劲地断点调试。很多比赛环境调试功能并不顺手，与其死磕断点，不如在关键分支处加输出语句，排查中间量。赛后收藏一份带调试输出的模板，能让你的现场改动效率提高50%以上。
5. 一点训练体会与扩展
蓝桥杯的省赛真题更新就是一个“知识图谱”的搭建过程。每年大家追着新题看，其实看的不只是题本身，而是命题方向的变化。
我的体会是：2019年到2025年，蓝桥杯难度的上升趋势非常明显。从过去“会基础的就能拿省二”，到现在“熟练掌握搜索、DP、数论基础才能稳进省一”，这条曲线会一直往上走。
但我同时也想告诉你一个反直觉的观察：真正得高分的人，反而不怎么追逐新题怪题，他们做的最多的事情是把基础题反复做透。第十六届的压轴题再花哨，它的内核依然是前缀异或 + 哈希，这套思想在多少年前的题里就已经出现过了。考场上拼的很少是“我见过这道题”，而是“我能不能把见过的套路迁移到陌生场景”。
这份真题集还在更新中，我在梳理过程中也会陆续补充完整版的解析和代码。你现在看到的部分，已经足够支撑一轮有效的备赛训练了。后续更新上来后，我的建议是不要直接看答案，先把自己的解法写出来，再跟我或者其他题解对照分析优劣。这道工序，比单纯刷十道新题都要值钱。
如果你在备赛路上遇到想不通的题目，或者对我的解题思路有不同的看法，欢迎随时交流。毕竟比赛这回事，一个人走容易迷路，多几个人交换想法，路会清晰很多。
