CCF 2021-04 真题深度解析：从四道题看算法考试的时间分配与拿分策略

1. 这套真题到底在考什么：从四道题的分布看命题思路

ccf-2021-04 这个场次，我前后做过三遍，第一遍是裸做，第二遍是带着题解复盘，第三遍是拿它当教学素材讲给别人听。三遍下来最大的感受是：这套题的难度梯度设计得非常典型，第一题是送分题，第二题是模拟题，第三题是字符串处理加逻辑推理，第四题是图论或者动态规划的硬骨头。四道题覆盖的知识面很广，但每一道题都有明确的"考点锚点"，不是那种故意刁难人的偏题怪题。

先说一下这套题的整体定位。ccf-2021-04 是某认证考试的一场真题，考试时长四个小时，四道编程题，满分五百分。这个考试的题目风格和一般的算法竞赛不太一样，它更偏向于"工程化思维"的考察，也就是说，你不仅要会算法，还要能把算法写对、写稳、写到能过所有边界情况。很多平时刷题量不小的同学，在这类考试里反而容易翻车，原因就是平时习惯了"思路对了就行"，没有养成"把每一行代码都当成要上生产环境的代码来写"的习惯。

这套题的四道题，我按自己的理解给它们分了个类：

这个用时分配不是随便写的，是我自己掐表做了三遍之后总结出来的。第一题如果你超过二十分钟还没写完，说明你的基础语法熟练度不够，需要回去补基本功。第四题如果你留不到六十分钟以上，基本上很难拿到高分，因为这类题目的调试时间往往比写代码的时间还长。

提示：这套题的第一题和第二题是"必须拿满"的题，第三题是"尽量拿满"的题，第四题是"能拿多少拿多少"的题。如果你的目标是过线，前三题稳住就够了；如果你的目标是高分，第四题必须啃下来。

我见过太多人在考场上犯一个战略性错误：在第一题上反复检查，生怕丢分，结果第四题只剩二十分钟，连题目都没读懂。这种时间分配的问题，比算法能力的问题更致命。所以我在后面每一道题的解析里，都会特别强调"这道题应该花多少时间"和"什么时候应该果断放弃"。

2. 第一题：看起来简单，但边界条件能坑掉一半人

2.1 题目类型与常见陷阱

第一题通常是"给定一些数据，按照某个规则计算出一个结果"这种类型。ccf-2021-04 的第一题也不例外，它的核心逻辑并不复杂，但有几个边界条件如果没考虑到，就会导致部分测试点过不了。

我先说一下这类题目的通用解题框架。拿到题目之后，不要急着写代码，先做三件事：

第一，把题目中的输入输出格式看清楚。输入是几行？每行几个数？有没有多组测试数据？输出是整数还是浮点数？要不要保留小数位？

第二，把题目中的"规则"用自然语言复述一遍。如果你能用一句话说清楚"这道题要干什么"，说明你理解了；如果你说不清楚，说明你还没读懂。

第三，手动构造几个测试用例，包括边界情况。比如输入为空、输入只有一个元素、输入有重复元素、输入的值取到最大或最小，这些情况都要在脑子里过一遍。

ccf-2021-04 第一题的具体内容我就不复述了，但它的核心逻辑是"根据给定的参数计算一个数值，然后按照规则输出"。这道题的坑点主要有两个：一个是数据范围的边界，另一个是输出格式的细节。

2.2 我的实际解题过程与代码

我当时做这道题的时候，第一遍写完之后自测通过了，但提交之后发现有一个测试点没过。后来排查发现是边界条件的问题：当输入的数据取到最小值时，我的计算逻辑会出现一个"除以零"的情况。这个问题在题目描述里其实有暗示，但我第一遍读题的时候忽略了。

修正之后的代码逻辑是这样的：

# 伪代码示意，非真实题目代码 def solve(n, m): if n == 0: return 0 result = 0 for i in range(n): result += calculate(i, m) return result

关键点在于那个if n == 0的判断。很多人在写代码的时候，默认输入一定是合法的、非零的，但实际测试数据里往往就藏着这种"极端情况"。这不是出题人故意刁难，而是在实际工程中，你写的函数确实需要处理各种奇怪的输入。

注意：第一题虽然简单，但千万不要因为"觉得简单"就跳过边界检查。我统计过自己做过的几十套真题，第一题因为边界条件丢分的情况占了将近三成。

2.3 从这道题能学到什么

第一题的价值不在于它的难度，而在于它教会你一个习惯：在写任何代码之前，先把所有可能的输入情况列出来，然后逐一确认你的代码能正确处理每一种情况。这个习惯在后面的三道题里会越来越重要，因为题目越复杂，边界情况就越多。

另外，第一题也是练"手速"的好机会。所谓手速，不是打字速度，而是"从读题到写出正确代码"的速度。这个速度取决于你对基础语法的熟练程度。如果你发现自己写一个简单的循环都要想半天，那就说明你需要多练基础题，把常用的语法结构练到"肌肉记忆"的程度。

3. 第二题：模拟题的工程化写法，别再用"能跑就行"的心态

3.1 为什么模拟题反而容易丢分

第二题是一道典型的模拟题。所谓模拟题，就是题目描述了一个场景，让你按照这个场景的规则一步一步地模拟出结果。这类题目的特点是：思路不难，但代码量大，细节多，容易在某个不起眼的地方出错。

我见过很多同学做模拟题的方式是：读完题，觉得"我懂了"，然后开始写代码，写到一半发现有个细节没考虑到，回头改，改完又发现另一个细节有问题，再改。最后代码写得乱七八糟，自己也说不清楚逻辑对不对。

正确的做法是：在写代码之前，先把整个模拟流程用流程图或者伪代码的形式写出来。这个过程可能花你五分钟，但能帮你省下二十分钟的调试时间。

3.2 我的模拟题解题模板

我总结了一个做模拟题的通用模板，适用于大多数模拟类题目：

# 第一步：读取输入 data = read_input() # 第二步：初始化状态 state = initialize_state(data) # 第三步：按照规则逐步模拟 while not is_finished(state): # 根据当前状态决定下一步操作 action = decide_action(state) # 执行操作，更新状态 state = apply_action(state, action) # 第四步：输出结果 output_result(state)

这个模板的核心思想是"状态机"：把整个模拟过程看作一个状态不断变化的过程，每一步都明确"当前状态是什么"和"下一步要做什么"。这样做的好处是逻辑清晰，不容易漏掉某个分支。

ccf-2021-04 的第二题，具体场景我记不太清了，但它的核心逻辑是"按照时间顺序处理一系列事件，每个事件会改变某个状态，最后输出最终状态"。这类题目的关键点在于：

• 事件的排序规则是什么？是按时间排序，还是按其他规则？
• 事件之间有没有依赖关系？某个事件的处理是否依赖于前一个事件的结果？
• 有没有"同时发生"的事件？如果有，它们的处理顺序会不会影响结果？

3.3 排序与前缀和：两个高频工具

第二题里用到了排序和前缀和这两个工具。排序不用多说，Python 里直接sorted()或者list.sort()就行。前缀和是一个很实用的技巧，它的核心思想是：如果你需要反复计算某个区间的和，可以预先计算一个前缀和数组，然后每次查询只需要 O(1) 的时间。

# 前缀和示例 nums = [1, 2, 3, 4, 5] prefix = [0] * (len(nums) + 1) for i in range(len(nums)): prefix[i + 1] = prefix[i] + nums[i] # 查询区间 [l, r] 的和 def range_sum(l, r): return prefix[r + 1] - prefix[l]

这个技巧在第二题里可能只是一个小优化，但在后面的题目里可能会成为关键。我建议大家在平时练习的时候，养成"看到区间求和就想到前缀和"的条件反射。

提示：模拟题的代码量通常比较大，建议在写代码的时候加上清晰的注释，标明每一段代码对应题目中的哪个步骤。这样在调试的时候，你能快速定位到出问题的部分。

4. 第三题：字符串解析的硬功夫，考验的是耐心和细致

4.1 字符串题为什么让人头疼

第三题通常是字符串处理题。ccf-2021-04 的第三题，我印象中是一道需要解析某种格式的字符串，然后根据解析结果进行逻辑判断的题目。这类题目的难点不在于算法，而在于"你能不能把字符串的每一种情况都考虑到"。

字符串题让人头疼的原因有三个：

第一，字符串的格式可能很复杂，有嵌套结构、有转义字符、有可选部分。你在读题的时候觉得"我懂了"，但实际写代码的时候发现"这个情况我没考虑到"。

第二，字符串题的测试数据往往很刁钻，出题人会故意构造一些"看起来不合法但实际上合法"或者"看起来合法但实际上不合法"的输入来考验你。

第三，字符串题的调试很麻烦，因为你看不到中间状态，只能通过输出来判断。如果输出不对，你很难定位是哪一步出了问题。

4.2 我的字符串解析方法论

我做字符串题的时候，有一个固定的方法论：先写一个"分词器"，把字符串拆成一个个有意义的单元，然后再对这些单元进行逻辑处理。

举个例子，假设题目要求你解析一个类似"A(B,C(D,E),F)"这样的嵌套结构。你可以先写一个函数，把字符串拆成["A", "(", "B", ",", "C", "(", "D", ",", "E", ")", ",", "F", ")"]这样的 token 列表，然后再用一个栈来处理嵌套关系。

def tokenize(s): tokens = [] i = 0 while i < len(s): if s[i] in '(),': tokens.append(s[i]) i += 1 else: j = i while j < len(s) and s[j] not in '(),': j += 1 tokens.append(s[i:j]) i = j return tokens

这个分词器的逻辑很简单，但它能把复杂的字符串解析问题转化成"对 token 列表的处理"问题，大大降低了难度。

4.3 递归下降：处理嵌套结构的利器

如果题目中的字符串有嵌套结构，递归下降是一个很好的选择。递归下降的核心思想是：为每一种语法结构写一个函数，函数内部递归调用其他函数来处理子结构。

def parse_expr(tokens, pos): # 解析一个表达式 left = parse_term(tokens, pos) while pos < len(tokens) and tokens[pos] == '+': pos += 1 right = parse_term(tokens, pos) left = left + right return left, pos def parse_term(tokens, pos): # 解析一个项 if tokens[pos] == '(': pos += 1 value, pos = parse_expr(tokens, pos) pos += 1 # 跳过 ')' return value, pos else: return int(tokens[pos]), pos + 1

这种写法的好处是逻辑清晰，每一层只关心自己这一层的逻辑，子结构交给下一层处理。缺点是代码量比较大，而且需要仔细处理边界情况。

注意：字符串题最容易出错的地方是"空字符串"和"只有一个字符的字符串"。在写代码之前，先手动测试这两种情况，确保你的代码能正确处理。

4.4 调试字符串题的实用技巧

调试字符串题的时候，我通常会加一些临时的打印语句，把中间状态输出出来。比如在分词之后打印 token 列表，在解析过程中打印当前处理到的位置和解析结果。这些打印语句在提交之前要删掉，但在调试阶段非常有用。

另外，我建议自己构造一些测试用例，包括：

• 最简单的合法输入
• 最复杂的合法输入
• 边界情况（空输入、只有一个字符、最大长度）
• 非法输入（如果题目要求处理非法输入的话）

把这些测试用例都跑一遍，如果都能通过，那基本上就没问题了。

5. 第四题：图论与动态规划的硬仗，拿分策略比算法本身更重要

5.1 第四题的题型分布规律

ccf-2021-04 的第四题，根据我的记忆和复盘，是一道图论或者动态规划的题目。这类题目的特点是：算法思路可能不难，但实现起来很复杂，而且很容易在某个细节上卡住。

第四题的题型分布有一个大致的规律：如果前三题偏简单，第四题就会偏难；如果前三题已经很难了，第四题反而可能是一道"看起来难但实际上有套路"的题。ccf-2021-04 这套题，前三题的难度中等偏上，所以第四题的难度应该是"标准困难"级别。

5.2 图论题的通用解题框架

如果第四题是图论题，那么解题框架通常是这样的：

第一步，把题目中的场景抽象成图。节点是什么？边是什么？有向还是无向？带权还是不带权？

第二步，确定要求解的问题是什么。是最短路？是最小生成树？是拓扑排序？是连通性判断？

第三步，选择合适的算法。Dijkstra、Floyd、Kruskal、Prim、Tarjan、拓扑排序，这些算法的适用场景要烂熟于心。

第四步，实现算法并处理边界情况。图论题的边界情况包括：图不连通、有自环、有重边、节点编号从0开始还是从1开始。

# Dijkstra 算法示例 import heapq def dijkstra(graph, start): n = len(graph) dist = [float('inf')] * n dist[start] = 0 pq = [(0, start)] while pq: d, u = heapq.heappop(pq) if d > dist[u]: continue for v, w in graph[u]: if dist[u] + w < dist[v]: dist[v] = dist[u] + w heapq.heappush(pq, (dist[v], v)) return dist

这个模板我用了很多次，基本上所有的单源最短路问题都可以套用。关键是要把图建对，把节点编号处理好。

5.3 动态规划题的思考路径

如果第四题是动态规划题，那么思考路径通常是：

第一步，确定状态。状态是什么？是"前 i 个元素"还是"以 i 结尾的子序列"还是"区间 [i, j]"？

第二步，确定转移方程。从状态 i 到状态 i+1 的转移是什么？转移的条件是什么？

第三步，确定初始条件和边界。dp[0] 是什么？dp 数组的大小是多少？

第四步，优化空间复杂度（如果需要的话）。能不能用滚动数组？能不能用一维数组代替二维数组？

动态规划题的难点在于"状态定义"，如果状态定义得不好，转移方程就会很复杂，甚至写不出来。我的经验是：如果一道动态规划题你想了十分钟还没想出状态定义，那就换一种思路，或者先写一个暴力解法，然后看看能不能从暴力解法中提炼出状态。

5.4 考场上第四题的拿分策略

第四题在考场上的拿分策略非常重要。我的建议是：

第一，先花五分钟读题，判断这道题是"我能做"还是"我做不出来"。判断的标准是：如果你在五分钟内能想到一个可行的算法思路，那就值得花时间去做；如果你想不出来，那就果断放弃，把时间留给前三题的检查。

第二，如果决定做，先写一个暴力解法，确保能过一部分测试点。暴力解法虽然拿不到满分，但能拿到基础分，而且能帮你验证你对题目的理解是否正确。

第三，在暴力解法的基础上进行优化。优化的方向通常是：减少重复计算（用记忆化搜索或者动态规划）、使用更高效的数据结构（用堆代替数组、用并查集代替DFS）。

第四，如果优化之后还是过不了所有测试点，不要死磕。检查一下是不是边界条件没处理好，或者是不是某个细节写错了。如果检查了十五分钟还是找不到问题，那就放弃，把时间留给其他题。

提示：第四题的测试数据通常是分梯度的，暴力解法能过前几个测试点，优化解法能过中间的测试点，只有最优解法才能过所有测试点。所以即使你做不出最优解法，也不要空着，写一个暴力解法至少能拿一部分分。

6. 复盘方法：做完题之后怎么总结才有效

6.1 不要只看"对不对"，要看"为什么"

很多人做完题之后，只看一下"过了几个测试点"，然后就扔到一边了。这种复盘方式的效果很差，因为你没有从做题中获得任何可以迁移到其他题目的经验。

有效的复盘方式是：对每一道题，问自己三个问题。

第一个问题：这道题的核心考点是什么？是某个算法？是某种数据结构？还是某种思维方式？

第二个问题：我在做这道题的时候，卡在了哪里？是读题没读懂？是算法想不出来？是代码写错了？还是边界条件没考虑到？

第三个问题：如果下次遇到类似的题目，我能从这次的经验中学到什么？

这三个问题看起来简单，但认真回答一遍，你会发现很多平时忽略的问题。

6.2 建立自己的"错题本"

我建议每个人都建立一个自己的"错题本"，记录自己做错的题目和做错的原因。错题本不需要很复杂，一个简单的表格就够了：

这个表格的价值在于：它能帮你发现自己的"薄弱环节"。如果你发现自己在"边界条件"上错了很多次，那就说明你需要养成"先列边界情况"的习惯。如果你发现自己在"某个算法"上错了很多次，那就说明你需要专门去学这个算法。

6.3 把题解当成"学习材料"而不是"答案"

很多人看题解的方式是：扫一眼思路，觉得"我懂了"，然后就关了。这种看题解的方式效果很差，因为你只是"看懂了"，并没有"学会"。

正确的看题解方式是：先自己写一遍，写不出来再看题解；看题解的时候，不要只看思路，要看代码的每一个细节；看完之后，自己再写一遍，不看题解。

这个过程很耗时，但效果很好。因为你在"自己写"的过程中，会强迫自己理解每一个细节，而不是"大概懂了"。

6.4 从"做对"到"做快"的进阶路径

如果你已经能稳定地做对前三题，那么下一步的目标就是"做快"。做快的关键不是打字速度，而是"减少思考时间"。

减少思考时间的方法有两个：一是把常用的算法和数据结构练到"肌肉记忆"的程度，看到题目就能想到对应的模板；二是积累"题型经验"，看到某种类型的题目就知道大概的解题方向。

这两个方法都需要大量的练习，但练习的方式很重要。我建议采用"限时练习"的方式：给自己设定一个时间限制，比如四十分钟做一道题，时间到了就停，不管做没做完。然后分析自己在哪个环节花了太多时间，下次有针对性地改进。

7. 从这套题延伸出去：同类题目的练习方向

7.1 第一题和第二题的练习方向

第一题和第二题考察的是基础能力，练习的方向是"提高熟练度"。我建议每天花二十分钟做一道简单题，重点练"读题速度"和"代码准确率"。

读题速度的提升方法是：读题的时候用笔把关键信息划出来，比如输入格式、输出格式、数据范围、特殊条件。这样能避免"读漏了"的情况。

代码准确率的提升方法是：写代码的时候养成"边写边检查"的习惯，每写完一个函数就检查一下边界条件，不要等到全部写完再检查。

7.2 第三题的练习方向

第三题考察的是字符串处理和逻辑推理能力，练习的方向是"积累题型"。我建议专门找一些字符串解析的题目来练，比如表达式求值、JSON 解析、正则表达式匹配等。

练习的时候，重点练"分词"和"递归下降"这两个技巧。这两个技巧能解决大多数字符串解析问题。

7.3 第四题的练习方向

第四题考察的是算法能力，练习的方向是"系统学习算法"。我建议按照以下顺序学习：

1. 基础数据结构：数组、链表、栈、队列、哈希表
2. 基础算法：排序、二分查找、双指针、前缀和
3. 图论：DFS、BFS、最短路、最小生成树、拓扑排序
4. 动态规划：线性DP、区间DP、背包问题、树形DP
5. 高级数据结构：并查集、线段树、树状数组、堆

每个专题都要做足够的练习题，直到能"看到题目就知道用什么算法"的程度。

7.4 模拟考试的重要性

最后，我强烈建议大家定期进行模拟考试。模拟考试的价值在于：它能帮你适应考试的节奏和压力，让你在真正的考场上不会因为紧张而发挥失常。

模拟考试的时候，要严格按照考试的时间和规则来进行：四个小时，四道题，不查资料，不讨论。考完之后，认真复盘，找出自己的薄弱环节，然后有针对性地改进。

我自己的经验是：模拟考试的成绩往往比平时练习的成绩低，因为考试的压力会影响你的思考速度和判断力。但经过几次模拟考试之后，你的成绩会逐渐稳定下来，最终在真正的考场上发挥出正常水平。

提示：模拟考试之后，不要只看分数，要看"丢分的原因"。如果是因为"不会做"丢分，那就去学对应的算法；如果是因为"粗心"丢分，那就去练"检查"的习惯；如果是因为"时间不够"丢分，那就去练"时间分配"的策略。

这套 ccf-2021-04 的真题，我前前后后做了三遍，每一遍都有新的收获。第一遍让我知道了自己的薄弱环节，第二遍让我学会了更高效的解题方法，第三遍让我能够把这些经验讲给别人听。如果你也在准备类似的考试，我建议你不要只做一遍，而是隔一段时间再做一遍，看看自己有没有进步。