LeetCode周赛无伤AK攻略：从算法原理到实战技巧

1. 先搞清楚“无伤AK”到底意味着什么

在 LeetCode 周赛里，“无伤AK”指的是在比赛规定时间内，以零次错误提交（Wrong Answer, WA）或超时（Time Limit Exceeded, TLE）等罚时，一次性通过所有题目。这不仅仅是“做完了”，而是要求极高的一次性正确率和代码稳定性。对于排名靠前的选手，尤其是国服前几十名，这几乎是冲击更高名次的必要条件，因为一次罚时可能就会导致排名下滑几十甚至上百位。

这次第 512 场周赛，国服 22 名的成绩结合“无伤AK”，说明了两点：第一，选手具备快速、准确地解决所有四道题目的硬实力；第二，在高压的竞赛环境下，对代码细节、边界条件和时间复杂度的把控非常到位。很多人刷题能 AC，但一到周赛就各种 WA，问题往往出在读题、思路实现和自测这三个环节的衔接上。

所以，看这类实况复盘，重点不是膜拜排名，而是拆解高手在 90 分钟里，如何分配时间、如何规避陷阱、以及面对“老年痴呆数数”和“读题吃力”这种真实状态时，如何调整策略并保持正确率。这对于想提升周赛成绩、尤其是想稳定进入前几百名的同学，比单纯看题解更有价值。

2. 周赛前的“热身”与状态管理：不只是打开网页

很多人参加周赛就是到点打开网页开始做，这其实浪费了最重要的适应期。从高手的习惯来看，赛前 10-15 分钟是有固定流程的。

2.1 环境与工具检查

这不是废话。我见过有人因为编译器自动补全没开、快捷键不熟悉、甚至网络延迟导致提交缓慢而心态爆炸。赛前你需要确认：

• 编码环境：你常用的 IDE 或编辑器是否打开且响应正常？本地调试的输入输出模板是否就绪？
• 浏览器：LeetCode 比赛页面是否登录正常？有没有烦人的弹窗？可以提前几分钟进入比赛页面等待。
• 心态准备：告诉自己，前两题是“必拿分”，目标是快速且无罚时通过，为后两题争取时间。不要一开始就想着冲击难题。

2.2 “读题吃力”的应对策略

标题里提到“读题越来越吃力”，这非常真实。周赛题目描述有时会比较绕，或者故意设置一些容易忽略的限制条件。高手的读题方法是结构化提取信息：

1. 先扫一眼数据范围：这直接决定了你能用什么复杂度的方法。n <= 10^3和n <= 10^5的思考方向完全不同。
2. 标记关键约束：在脑中或草稿纸上立刻记下：哪些操作是允许的？输入输出的具体格式？有没有多组查询？有没有“不可逆”的操作？
3. 自己转化例子：题目给的样例输入输出，不要只看，要用手（或脑）跟着走一遍流程，确保你理解的“操作”和题目描述一致。很多“读题”错误，其实是样例都没模拟明白。

“老年痴呆数数”则体现在边界条件上，比如数组下标从 0 开始还是 1 开始，循环的终止条件是否包含等号，累加时会不会溢出。这些需要形成肌肉记忆和条件反射。

3. 四道题目的节奏把控与核心思路拆解

一场周赛通常由易到难。我们以常见的四题结构来还原一下可能的节奏和解题焦点。

3.1 第一题：签到题，拼的是速度和绝对正确

• 目标：5分钟内 AC，零罚时。
• 典型题型：简单的模拟、数组操作、字符串处理、基本数学。
• 避坑点：
  • 仔细读输出格式：是否需要大小写、空格、换行？
  • 警惕边界：空数组、单个元素、极大/极值。
  • 代码简洁：不要炫技，用最直白、最不容易出错的方式写。例如，遍历就老老实实用for循环，别一上来就想用复杂的迭代器或函数式编程。

示例思路（假设题意为数组元素处理）：

class Solution: def solve(self, nums: List[int]) -> int: # 1. 初始化答案或累加器 ans = 0 # 2. 清晰遍历，明确循环变量和范围 for num in nums: # 3. 核心逻辑，一步一检查 if some_condition(num): # 条件判断要清晰 ans += operation(num) # 操作要明确 # 4. 返回前再确认一下类型和边界 return ans

关键：一次写对，直接提交。不要在第一题上节省那 30 秒检查时间而去冒 WA 的风险。

3.2 第二题：思维题或简单数据结构

• 目标：10-15分钟内 AC，依然追求无罚时。
• 典型题型：需要一点巧思的贪心、简单的二分查找、栈/队列的应用、哈希表计数。
• 避坑点：
  • 证明贪心策略：哪怕不严格证明，也要心里过几个反例，确保你的直觉策略是成立的。
  • 数据结构选择：用set还是dict？用list还是deque？选择的标准是查询、插入、删除的复杂度是否符合数据范围。
  • 避免过度设计：有时暴力方法就能过，别非得想个复杂的算法。

示例思路（假设为贪心或哈希计数）：

class Solution: def solve(self, tasks: List[int]) -> int: from collections import Counter cnt = Counter(tasks) ans = 0 # 遍历计数结果，而不是原数组 for key, freq in cnt.items(): if freq == 1: # 无法完成任务的特殊情况 return -1 # 核心计算逻辑，向上取整的写法要熟练 ans += (freq + 2) // 3 # 举例：一种常见的分组向上取整 return ans

关键：思路比编码更重要。花 2-3 分钟在草稿纸上画一下，比直接在代码里试错要快得多。

3.3 第三题：中等难度算法，区分度开始显现

• 目标：20-25分钟内 AC，允许有一次思考调整，但仍要避免 WA。
• 典型题型：DFS/BFS、动态规划（DP）、二分答案、稍复杂的数据结构（如并查集、前缀和、单调栈）。
• 避坑点：
  • 状态定义：如果是 DP，把dp[i]代表什么写清楚，初始化要对。
  • 递归终止条件与 visited：如果是图论搜索，一定要防环，记得标记已访问节点。
  • 二分查找的边界：while left <= right还是<？更新left = mid + 1还是right = mid - 1？模板要固定用一套。

示例思路（假设为二维网格 DFS）：

class Solution: def solve(self, grid: List[List[str]]) -> int: m, n = len(grid), len(grid[0]) visited = [[False] * n for _ in range(m)] def dfs(i, j): if not (0 <= i < m and 0 <= j < n): return 0 if grid[i][j] == '0' or visited[i][j]: return 0 visited[i][j] = True area = 1 # 四个方向，注意边界 for di, dj in [(0,1),(0,-1),(1,0),(-1,0)]: area += dfs(i+di, j+dj) return area ans = 0 for i in range(m): for j in range(n): if grid[i][j] == '1' and not visited[i][j]: ans = max(ans, dfs(i, j)) return ans

关键：这类题是周赛的“胜负手”。能稳定快速解出第三题，排名就不会差。无伤的关键在于，写完代码后，用题目给的样例和至少一个自己设计的边缘样例（如全1、全0、单行、单列）在脑子里或草稿上跑一遍。

3.4 第四题：困难题，冲击高排名的关键

• 目标：剩余时间全力攻克，允许有思路迭代，但核心代码逻辑必须清晰。
• 典型题型：复杂 DP（状态压缩、数位 DP）、高级数据结构（线段树、树状数组）、图论（最短路、最小生成树、网络流）、数学或组合。
• 避坑点：
  • 时间评估：如果还剩 20 分钟，一个思路想了 10 分钟还没头绪，要果断止损，回去检查前三题是否有优化空间或隐藏错误。
  • 先写暴力，再优化：有时暴力解法（比如O(n^2)）能帮你理解问题本质，甚至可以通过部分数据点。先确保思路正确。
  • 利用数据范围反推算法：n <= 20可能是指数级或状压 DP；n <= 10^5要求O(n log n)或O(n)。

示例思路（假设为带限制的 DP）：

class Solution: def solve(self, nums: List[int], k: int) -> int: n = len(nums) # dp[i][j] 表示处理到前 i 个元素，状态为 j 时的最优解 # 初始化一个“不可能”的值，如 -inf dp = [[float('-inf')] * (k+1) for _ in range(n+1)] dp[0][0] = 0 # 初始状态 for i in range(1, n+1): val = nums[i-1] for j in range(k+1): # 状态转移1：不选第 i 个元素 dp[i][j] = max(dp[i][j], dp[i-1][j]) # 状态转移2：选第 i 个元素，需要满足条件 if j >= some_condition(val): new_j = j - some_condition(val) dp[i][j] = max(dp[i][j], dp[i-1][new_j] + val) # 最终答案可能不是 dp[n][k]，要根据题意确定 ans = max(dp[n]) return ans if ans != float('-inf') else -1

关键：第四题能做出来是锦上添花，但前提是前三题稳稳拿住且无罚时。冲击高排名（如国服前 50）时，第四题的解题速度和正确率才是核心。

4. 实现“无伤”的具体技术习惯与赛后复盘

“无伤”不是运气，是一系列可训练的习惯。

4.1 编码时的“防呆”检查清单

在点击“提交”按钮前，花 30 秒快速过一遍这个清单：

1. 变量初始化：所有用到的变量都正确初始化了吗？特别是累加ans、最大值max_val（初始应为负无穷或第一个元素）、最小值min_val。
2. 循环边界：for i in range(n)还是range(1, n)？while left <= right的退出条件会导致死循环吗？
3. 数组下标：在循环内访问nums[i-1]还是nums[i]？特别是在处理前缀和或 DP 时。
4. 整数溢出：Python 一般不需要担心，但如果你在用其他语言（如 C++、Java），中间结果用int会溢出吗？是否需要long long？
5. 返回值：函数返回的类型对吗？如果可能无解，返回的默认值（如 -1）是否符合题目要求？
6. 样例自测：把题目给的样例，用眼睛或者打印语句在脑子里跑一遍，输出是否一致？

4.2 调试与提交策略

• 本地测试：对于复杂逻辑，可以在 IDE 里写一个简单的main函数，用样例测试。但周赛中时间紧，更多依赖“脑测”和 LeetCode 的“执行代码”功能。
• 利用“执行代码”：提交前，一定要用“执行代码”功能跑一遍题目提供的所有样例。这是避免 WA 的最后一道防线。
• 一次提交原则：对于简单题和中等题，目标是“一次提交通过”。这意味着你的代码在逻辑上已经考虑了所有你想到的边界情况。如果没把握，宁愿多花 1 分钟在草稿上演算。

4.3 赛后的深度复盘比做题更重要

比赛结束，无论成绩好坏，复盘才是真正提升的时候。

1. 重做错题：如果有 WA 或没做出来的题，不要马上看题解。关闭比赛界面，当做一个新题，重新独立做一遍，直到 AC。
2. 对比最优解：AC 后，去看比赛排名靠前选手的代码（LeetCode 有“提交记录”功能）。重点对比：
   • 思路差异：他们的解法更简洁或更高效在哪里？
   • 代码实现：有没有更漂亮的写法或语法技巧？（例如 Python 的列表推导、collections模块的妙用）
   • 复杂度：他们的时间/空间复杂度是否更优？
3. 总结“无伤”失败点：如果这次有罚时，是因为什么？
   • 读题失误？（标记下来，以后同类描述要警惕）
   • 边界条件漏了？（把这个边界条件记到你的“常见坑点”本子里）
   • 算法复杂度算错？（重新评估数据范围与复杂度的对应关系）
   • 编码粗心？（强化“防呆”检查清单）

5. 从“能做”到“快且稳”的长期训练建议

想稳定取得好排名，尤其是追求“无伤AK”，需要系统性的训练。

5.1 专题强化与弱点攻克

不要随机刷题。根据周赛常考题型，进行专题训练：

• 每周一个专题：比如本周专注“二分查找”，就刷 10-15 道不同难度的二分题，总结模板和变体。
• 建立解题模板库：把 DFS/BFS、DP、并查集、滑动窗口等高频算法的标准写法，整理成自己最熟悉的模板，形成肌肉记忆。
• 针对性补强：如果你总是在图论题上栽跟头，那就集中一段时间猛攻图论。

5.2 模拟赛与时间压力训练

• 参加虚拟竞赛：LeetCode 有往期周赛题库，可以当作模拟赛，严格计时 90 分钟。
• 分析时间分布：模拟赛后，分析每道题花了多少时间。目标是：Q1 (<5min), Q2 (<15min), Q3 (<30min)，给 Q4 留出至少 30 分钟。
• 训练“一次通过”能力：在平时练习中，就刻意要求自己，每道题只提交一次。如果错了，先不看提示，自己找出 bug。这能极大提升代码正确率。

5.3 心态与体力管理

• 周赛是马拉松：90 分钟高强度思考非常消耗精力。保证比赛前休息充足，可以准备一点水。
• 开局不顺怎么办：如果第一题就卡住超过 10 分钟，心态容易崩。这时要果断跳过去看第二题。很多时候，第二题可能更简单。拿到一分是一分，不要在一棵树上吊死。
• “老年痴呆”是常态：高手也会看错题、数错数。接受这种状态，用流程（如检查清单）去对抗偶然的失误，而不是指望自己永远不犯错。

追求“无伤AK”和国服高排名，本质是追求极致的稳定性和效率。它要求你不仅知道算法，还要在高压下能精准地翻译成代码，并且一遍过。这需要将正确的解题习惯内化成本能，并通过大量的刻意练习来巩固。从每次周赛后认真的复盘开始，记录下每一个让你产生罚时的“坑”，下一次比赛前再温习一遍，你会发现自己“无伤”的次数越来越多。