2024年3月的GESP四级考试，是我带学生复盘时绕不开的一套真题。这个级别正好卡在"会写基础C++"和"能解算法入门题"之间，客观题偏向语法细节和逻辑边界，编程题则考验你把想法稳定落成代码的能力。很多人在三级阶段靠着模板和直觉能过，一到四级就发现时间不够、边界处理不对、代码写完也不敢提交。如果你准备冲刺四级，或者手里正好拿到202403这套卷子当训练材料，这篇文章会把考点分布、三道编程大题的做法、以及容易丢分的坑一次讲清楚。

1. 202403四级真题全景：考点分布与难度曲线

1.1 从试卷结构反推：四级到底考什么

GESP四级的卷面结构相对固定：单选题约15道、判断题约10道、编程题3道。客观题覆盖的是基础语法、表达式求值、数组下标、函数传参、指针入门这些知识点，编程题则集中在模拟、递归、字符串处理和结构体排序上。202403这套题的风格是：不刻意堆砌偏题怪题，但每一道题都留了边界条件等着你踩。

单选里有一道考静态局部变量的生命周期，另一道考二维数组按行优先存储的地址计算，难度不大，但需要你对"变量到底存在哪里、生命周期多长"有清晰认识。判断题则更喜欢把一段代码改得看似正确，再让你判断，典型手法是把循环边界从<改成<=，或者把逻辑与的短路求值混进条件里。如果你平时只靠编译器报错来学语法，这类题会非常难受。

编程题的三道题拉开明显梯度：第一道是格点路径计数，第二道是结构体排序，第三道是括号序列合法判定。前两题认真做可以拿满，第三题需要你熟悉栈的用法，但也只是四级范围内的经典应用。整套试卷对算法深度的要求不算高，真正的区分度在"能否在压力下不写错边界、不丢分"这件事上。

下面用一张表把这个结构写清楚，方便你做专项训练时对号入座：

1.2 难度曲线与时间分配：客观题别恋战，编程题留足时间

这套卷子的难度并不均匀。客观题前八题基本是送分题，学过数组和循环就能拿；从第九题开始，复合条件和指针相关题目会明显变难，想全对需要极其仔细。编程题的第一题属于"状态梳理清楚就能AC"的类型，第二题考验比较器写法，第三题需要递归思维或栈模拟，难度阶梯拉得很开。

我复盘时给学生的建议是：总共120分钟，客观题最多用35分钟，遇到卡壳的题先标记跳过去，不要反复纠结，因为后面编程题才是分值大头。编程题至少留85分钟，先做第一题把稳拿的分拿到手，再做第二题，第三题如果思路不清晰，也要先把暴力写法写出来，能拿部分分就拿部分分。真实考试里最亏的情况是前面客观题抠了10分钟，导致编程题最后一题连样例都没跑完。

判断客观题"是否该放弃"有个经验标准：一道题你已经看了两分钟仍然没有明确思路，说明在这套卷子里它的难度超出你当前水平，先蒙一个答案，把时间交给编程题。单选和判断的分值虽然单题不高，但积少成多，策略性放弃是为了整体得分最大化。

2. 核心考点精讲：四级高频知识点的正确打开方式

2.1 递归别只背模板：参数变化与状态恢复是关键

202403 有一道和递归相关的题目，本质是深度优先搜索。题目大意是统计一个长度为 n 的字符串组合数量，字符只能取自若干种候选，并且要求相邻字符满足一定限制。很多学生看到这道题第一反应是"递归模板我会"，但真正动手写的时候就卡在了一个问题上：递归函数里改了全局状态，却忘了恢复。

下面这种写法就是典型错误：

int ans = 0; int cnt[26] = {0}; void dfs(int pos, int len) { if (pos > len) { ans++; return; } for (int c = 0; c < 3; c++) { cnt[c]++; // 修改了全局状态 dfs(pos + 1, len); cnt[c]--; // 如果不恢复，下个分支就脏了 } }

为什么必须恢复？因为递归本质上是状态的试探与回溯。dfs进入第一个分支后修改了cnt，如果返回时不清空这个修改，第二个分支看到的初始状态就是错误的。局部变量没有这个问题，因为函数调用栈天然为每一层调用保存了独立副本。所以一条铁律是：只要在递归里改动了全局数组、全局计数器，就必须在同一层递归返回前做对称的恢复动作。

实际操作中，我建议在小样例上手动展开调用树。比如长度 n=2 的例子，画出每一层cnt的取值，看是否在回溯后回到最初状态。这个方法比瞪着眼睛调试快得多。另外，如果递归深度可能达到上万层，要注意栈溢出风险，四级题一般不会给到这么深，但思想上要有数。

2.2 结构体加排序：sort 比较器到底怎么写才稳

四级几乎每年都要考一次结构体排序，202403 的编程第二题就是成绩排名。这类题本身不难，但失分点集中在sort比较器的写法上。很多人会用sort(a, a + n, cmp)，也写得出基本逻辑，但没有意识到std::sort是不稳定排序。

不稳定排序意味着如果比较器认为两个元素"相等"，它们的相对顺序可能会变化。所以比较器必须把所有并列条件都写全，比如总分相同再看语文，语文还相同再看学号。只写一个条件，你的排序结果就可能是随机的。

struct Student { int id, total, chinese; }; bool cmp(const Student &a, const Student &b) { if (a.total != b.total) return a.total > b.total; if (a.chinese != b.chinese) return a.chinese > b.chinese; return a.id < b.id; }

另一个容易忽略的点是严格弱序。cmp(a, a)必须返回false，如果所有字段都相等，应该落在最后一行return a.id < b.id，而当 id 也相等时，这个表达式会返回false，恰好满足要求。如果你为了省事改成return a.id <= b.id，就违反了严格弱序，可能引起程序崩溃，不是简单排序错乱那么简单。

我建议提交前专门构造一组"全部字段相同"的数据测试。如果程序没有崩且输出顺序稳定，说明比较器大概率没问题。还要记住sort的区间是[begin, end)，手写sort(a, a + n, cmp)没毛病，但用 vector 时别把end()写成size()，这类低级错误在考场上出现率出乎意料地高。

2.3 字符串与 STL 容器：迭代器失效和空串判断

202403 的选择题和编程题都涉及字符串处理。有一道题问find函数的返回值类型，正确答案是string::size_type，也就是无符号整数，找不到时返回npos。很多同学习惯写if (s.find(ch) == -1)，在多数编译器里能工作，因为-1会隐式转换成很大的无符号数，刚好和npos相等，但这属于靠巧合吃饭，不推荐。

另一个高频考点是迭代器失效。比如你写循环删除 vector 中的元素：

for (auto it = v.begin(); it != v.end(); it++) { if (*it % 2 == 0) v.erase(it); }

这段代码看似能删掉偶数，实际运行却可能跳元素甚至崩溃。因为erase会使当前迭代器失效，it++再去访问就是未定义行为。正确写法是：

for (auto it = v.begin(); it != v.end(); ) { if (*it % 2 == 0) it = v.erase(it); else it++; }

用erase返回的下一个迭代器重新赋值给it，后续循环才安全。如果你觉得迭代器别扭，也可以从尾部向前遍历，配合下标删除，效果一样。四级不要求你深挖迭代器底层，但这类判断题目在卷子里经常出现，你要能一眼看出"删除后继续用旧迭代器"的问题。

空字符串判断也是常见考点。有些人写if (s.length())判断非空，这个没问题；但有人写成if (s == "")，也 OK。最容易出错的是把s.find的结果和bool混用，比如if (s.find(ch))，这在语义上完全不对，因为找到字符时返回的是下标，不是布尔值。四级阶段一定要把 STL 基本接口的返回类型弄清楚，很多失分根本不是逻辑问题，而是接口用错了。

3. 编程大题逐题实战：读题、拆解、编码、验证

3.1 真题一：格点矩阵上的寻宝游戏

这道题根据考后复盘还原，大意是：给出一个 n 行 m 列的格点矩阵，每个格子里是 0 或 1，0 代表空地，1 代表障碍物。玩家从左上角出发，目标是走到右下角，每一步只能向右或向下走，不能走障碍物。求不同的路径总数对 1000000007 取模。

这道题放在四级的编程第一题，考察的是动态规划入门。n、m 范围在 1 到 30 之间，路径数量很大，但不需要高精度，只需要取模。核心转移公式很朴素：到达某个格子的路径数等于到达上方格子的路径数加上到达左方格子的路径数，如果当前格子是障碍物，路径数就是 0。

#include <bits/stdc++.h> using namespace std; const long long MOD = 1000000007LL; int main() { int n, m; cin >> n >> m; vector<vector<int>> grid(n, vector<int>(m)); for (int i = 0; i < n; i++) { string line; cin >> line; for (int j = 0; j < m; j++) { grid[i][j] = line[j] - '0'; } } vector<vector<long long>> dp(n, vector<long long>(m, 0)); if (grid[0][0] == 0) dp[0][0] = 1; for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { if (grid[i][j] == 1) continue; if (i > 0) dp[i][j] = (dp[i][j] + dp[i - 1][j]) % MOD; if (j > 0) dp[i][j] = (dp[i][j] + dp[i][j - 1]) % MOD; } } cout << dp[n - 1][m - 1] << "\n"; return 0; }

这道题最大的坑是输入格式。如果矩阵数字之间用空格分隔，用cin >> grid[i][j]就能读；如果每一行是一个连续字符串，就得用string读取再逐个转。考场上一定要先确认数据格式再写代码，不要想当然。另一个坑是起点本身是障碍物的情况，此时应该输出 0，单独初始化dp[0][0]正好处理了这个问题。

复杂度是O(n*m)，对 30 以内的数据毫无压力。实测按行优先遍历是对的，因为dp[i][j]只依赖上方和左方，这两个格子一定已经计算完毕。

3.2 真题二：成绩统计与名次生成

这道题要求的操作很直接：有 n 名同学，每个同学有学号、科目 A 成绩和科目 B 成绩，计算总分后排名。排名的规则是总分高的在前，总分相同时科目 A 成绩高的在前，再相同学号小的在前。最后输出前 k 名同学的学号和总分。

这类题在四级里几乎是必考题型，难点不在计算，在于排序规则。你需要用结构体把学生信息封装起来，然后给sort写一个比较器。注意学号可能带有前导零，比如00123，如果把它存成int，前导零就丢了，输出时不符合题目要求。稳妥做法是把学号定义成string，排序时字典序和数值序在固定长度下一致，输出也安全。

#include <bits/stdc++.h> using namespace std; struct Student { string id; int aScore, bScore, total; }; bool cmp(const Student &x, const Student &y) { if (x.total != y.total) return x.total > y.total; if (x.aScore != y.aScore) return x.aScore > y.aScore; if (x.bScore != y.bScore) return x.bScore > y.bScore; return x.id < y.id; } int main() { int n, k; cin >> n >> k; vector<Student> stu(n); for (int i = 0; i < n; i++) { cin >> stu[i].id >> stu[i].aScore >> stu[i].bScore; stu[i].total = stu[i].aScore + stu[i].bScore; } sort(stu.begin(), stu.end(), cmp); for (int i = 0; i < k; i++) { cout << stu[i].id << " " << stu[i].total << "\n"; } return 0; }

这道题我建议重点检查边界数据。全相同成绩的学生，排序后必须按照学号升序输出，因为比较器的最后一条规则保证了这一点。如果题目保证 k 不超过 n，可以不写min(k, n)，但如果想更稳，写成for (int i = 0; i < min(k, n); i++)也不会错。

说一个我在实际批改中反复看到的问题：比较器里只写了总分一个条件，总分相同的学生排序就乱套了。这不是 sort 的锅，是规则没写完整。以后无论刷题还是比赛，只要遇到多关键字排序，就把所有并列条件按题目顺序逐个写进比较器，一条都不能少。

3.3 真题三：括号序列的合法性检测

第三题给一个只包含()[]的字符串，判断括号序列是否合法。合法的定义包括普通意义上的成对匹配，以及不允许出现([)]这种交叉嵌套。长度不超过 1000，输出YES或NO。

这是栈应用的经典题目。思路是：遇到左括号就压栈，遇到右括号就看着栈顶能不能匹配，匹配就弹出，不匹配或者栈为空就是非法的。扫描完整个字符串之后，栈里如果还有剩余左括号也为非法。

#include <bits/stdc++.h> using namespace std; bool check(const string &s) { stack<char> st; for (char c : s) { if (c == '(' || c == '[') { st.push(c); } else { if (st.empty()) return false; char top = st.top(); if ((top == '(' && c == ')') || (top == '[' && c == ']')) { st.pop(); } else { return false; } } } return st.empty(); } int main() { string s; cin >> s; cout << (check(s) ? "YES" : "NO") << "\n"; return 0; }

这段代码的细节在于st.empty()判断要放在取栈顶之前。如果你先取st.top()再判断栈空，空栈上访问栈顶就是未定义行为，可能会让整个程序崩溃。另一个容易出错的地方是匹配成功后忘记pop，后面再遇到右括号时，栈顶还是旧括号，后果就是连锁误判。

如果题目允许空字符串，则空串是合法的，因为st.empty()返回真。做题时注意题面有没有强调s的长度范围，不要想当然认为长度至少为 1。第三题通常还有加强版，要求判断三种括号的优先级，但 202403 这道题只考两种，用栈已经足够。

3.4 编程题答题顺序与提交前规范

考场上的答题顺序，我一般建议按分值投入比来排。第一题路径计数属于读完题就有明确思路的类型，先做它；第二题排序是结构体基本功，再做；第三题括号检测如果之前没练过栈，可以先写一个基于匹配的朴素版本，至少拿部分分。

提交之前，每道题都要过一遍"最小数据、最大数据、异常数据"测试。最小数据能测出数组越界和初始条件问题，最大数据能观察运行时间，异常数据比如起点就是障碍、k 等于 0、空字符串，能把边界条件炸出来。这些自测用例不需要写到提交代码里，本地验证完就可以。

写代码时还要注意变量类型。路径计数和成绩总分虽然看起来不会超过int，但中间累加可能导致超出，所以我在代码里统一使用long long，取模前的大数也不会出问题。数组下标能用vector就不开裸数组，减少越界风险。这类习惯能让你少丢很多表情包分数。

4. 失分重灾区与备考建议：来自一线的排查实录

4.1 客观题里反复出现的五类逻辑陷阱

复盘 202403 的客观题，我发现失分点非常集中，几乎都围绕少量几个固定考点。下面把常见陷阱整理成速查表，考前过一遍能有效避坑：

这张表看起来简单，但真实考试不会直接问你逐字逐句的概念，而是把这些陷阱藏在代码片段里。做题时一定要逐行手算，不要凭"眼熟"直接选答案。尤其是判断题中出现"一定""总是"这类绝对化表述，大概率有反例，要多想一层。

4.2 编程题提交前的自检清单与调试技巧

很多人写完代码后信心满满，提交却拿 0 分，问题通常不在算法，而在一些非技术细节。我习惯在提交前按顺序检查五项：

• 输入输出格式：题目要求每行几个数、是否输出空格、换行符用"\n"还是endl。格式不对，判题系统直接判错。
• 变量初始化：全局变量默认是 0，局部变量不是。局部数组不初始化，里面是随机值，非常容易在小型测试用例上碰巧通过，大数据量就崩。
• 极端数据自测：n=1、k=0、空串、全部相同元素。这些边界用例最能暴露问题。
• 类型范围：涉及累加和乘法时统一用long long，别赌数据不会超int。
• 文件命名与提交要求：不同考试平台要求不同，主文件名、类名、函数名都不能写错，这不是技术问题，丢分最冤。

调试时我更喜欢用cerr打印变量，因为它不依赖程序主输出，不会污染答案格式。比如递归函数里加一行cerr << "pos=" << pos << " ans=" << ans << endl;，定位状态恢复问题非常有效。临提交前再把调试输出删干净，避免多余字符被当成答案的一部分。

4.3 冲四级的时间规划与训练方法

如果你现在的水平是三级能过、四级没底，我给一个六周训练框架。第一周集中补语法漏洞，重点看指针、引用、结构体、静态变量这些平时写题不太用到的知识点。第二周专门练结构体排序和字符串处理，把比较器写法练到不用想就能写对。第三周开始做递归和栈模拟题，每天至少一道，重点是画调用树、写状态恢复。第四周开始刷最近两年的真题，按考试时间模拟，训练时间分配。第五、六周进入复盘阶段，不追求新题量，而是把错题反复重写。

每周至少安排 4 次、每次 90 分钟以上的连续编码时间，中间不打断、不看手机。日常训练时，AC 不是终点，同一道题要尝试用不同方法写第二遍，比如路径计数可以用递推也可以记忆化递归，括号匹配可以用栈也可以用计数器，多角度重复能极大提升考场上的应变能力。

最后再分享一个我自己的习惯：做完每套四级真题后，把错题对应的考点记成一张卡片，包含题目描述、错误原因、正确解法三个板块。202403 这套卷子里的静态变量、迭代器失效、比较器完整规则等知识点，都是未来考试的高频复现点。你把这些卡片反复翻几遍，比盲目刷新题更有效。四级的真正分水岭，从来不是"会不会某个算法"，而是"能不能在有限时间内把简单的题写得足够稳"。