我说老李你说黑Hot100(71-80)这段题单，我前前后后刷了两遍。第一次是顺着列表往下推，到这一组突然感觉难度起了一个小台阶——前面很多题套一个经典模板就能过，但这一段开始把两三种模型揉在一起考，比如树上走回溯、数组里做DP，一个不注意就掉进超时或者边界错误里。第二遍我换了个方式，先按题型把十道题重新归堆，再逐类梳理框架，效果完全不同。所以这篇不是单纯列答案，而是把我在刷第71到80题时的复盘笔记公开出来：题型怎么分布、每类题的核心思路是什么、哪些细节会让你的代码从“能跑”变成“能过”。给正在刷这一段的人，也给那些打算备战算法面试、想把高频题型彻底吃透的人。
1. Hot100(71-80)到底在考什么：先看清题型分布
1.1 我看到的十题分布规律
以我刷到的版本为例，这一段的十道题大致可以分成这么几类：链表结构重排一道，二叉树层序或二叉搜索树的变体有三道，字符串和数组上的动态规划两道，回溯两道，单调栈一道，还有一道是看着简单但特别容易被边界条件坑到的配对题。这个分布不一定和你平台上的完全一致，因为Hot100题单在不同平台会微调，但大方向是一致的：前面那些题考的是“你知不知道这个模板”，从这一段开始，考的是“你有没有真的理解模板里的每个细节”。
我最初按顺序刷的时候有一个明显感受：70题之前，常常是看到题目就能想起一个标准解法，比如“这题就是经典的两数之和思路”“这题套个层序遍历模板就行”。到了71到80这里，题目描述往往更长，数据范围也给得更具体，甚至有些题把两个考点直接缝合在一个场景里。你如果不先做题型判断，很容易把简单问题复杂化，或者把复杂问题用最简单的暴力解去碰运气。
1.2 判断题目类型比动手写更重要
我的习惯是拿到题先不碰代码，在草稿纸上做三个动作：把数据范围写在左上角，把输出类型圈出来，然后逼自己用一句话概括这题在干什么。为什么要先看数据范围？因为数据规模直接决定了你能接受的复杂度。n小于20，你甚至可以理直气壮地用指数级回溯；n到了10的5次方，你还写一个双重循环，那就是在赌评测数据比较弱，大概率会超时。
判断题型有一个很好用的问法：把这题拆成若干个子问题之后，子问题的结果会不会被反复复用？如果会，这题大概率是动态规划。如果不复用，再看它是“在一堆选择里找合法路径”，那就是回溯或搜索；如果是链表或树结构，先想清楚操作会不会改变结构本身的连接关系。顺序重要的问题优先想双指针和栈，顺序不重要的想排序和哈希。这套判断流程熟练以后，五分钟内你基本就知道该往哪个方向使力了。我觉得很多人卡在中间难度题目上，不是不会写某一类解法，而是根本没有先完成这个类型归类。
1.3 为什么到这一段开始卡壳
以前我总以为刷题是“题做得越多越好”，但实际刷到Hot100(71-80)这一段，我发现自己真正缺的不是题量，而是“模式识别”的能力。前面几十题几乎是一对一的映射：看到逆序对就想到归并，看到连续子数组就想到前缀和。但这一段的题开始玩组合了，比如二叉树层序遍历和队列结合、数组DP和贪心结合、回溯和网格坐标结合。你至少要把每个单点模型练到肌肉记忆，才有余力去处理它们的组合。
这个道理有点像开车。新手练车时，踩离合、换挡、打灯每一件事都要单独想，遇到一个复杂路口就手忙脚乱；等这些动作都变成条件反射，你才能真正把注意力放在路况上。刷题也一样，模板和边界判断如果还没形成肌肉记忆，遇到综合题自然会卡住。所以我后来复盘时说的最多的一句话就是：不是这题难，是我对基础模型的熟练度还不够。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 链表和二叉树：这批题里的骨架类题目
2.1 链表重排：切半、反转、交错合并
这一组里最容易出问题的链表题，是那种要求“重排链表”的题目。它表面上是改一改指针顺序，实际上是把三个经典操作拼在一起：找中点、反转后半段、交错合并。我第一次写的时候，三个步骤每一个都能写对，但拼在一起就各种丢指针，最后形成了环，提交直接超时。
正确流程是这样：先用快慢指针找中点。慢指针每次走一步，快指针每次走两步，当快指针走到末尾时，慢指针正好停在中间。为什么不先遍历一遍算长度？因为快慢指针一次遍历就能同时拿到中点，而且还天然处理了链表长度为奇数和偶数的情况。找到中点之后，从slow.next开始作为后半段的头，把后半段做一次迭代反转。这里要特别注意，反转完之后一定要把slow.next置空，不然前后两段还是连着的，后面交错合并时就会绕成环。
最后是交错合并。我推荐的写法是使用临时变量先保存两个链表的后继节点，再修正指针指向前半段的下一节点和后半段的下一节点：
python复制def reorder(head):
if not head or not head.next:
return
slow, fast = head, head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
second = reverse(slow.next)
slow.next = None
first = head
while second:
tmp1 = first.next
tmp2 = second.next
first.next = second
second.next = tmp1
first = tmp1
second = tmp2
这个写法我后来反复用了很多次，核心就是“每一步改指针前，先把后继存下来”。链表题的大部分空指针异常和死循环，都来自你改了一条指针之后，原本的下一个节点找不到了。
2.2 二叉树层序变体：队列size是你的分界线
二叉树相关题目里，层序遍历是这一段的常客，但很少直接给你“按层输出节点”这种送分题，更多是让你输出之字形遍历、二叉树右视图、每层最大值之类的变体。你只要掌握了最原始的层序遍历，这些变体其实就是换一层皮。
层序遍历的关键是用队列，但很多新手容易漏掉一个动作：在开始遍历某一层之前，先用变量记录当前队列的长度。如果不缓存这个size，而是直接用while queue这种判断，你会把下一层新入队的节点也当成当前层来处理，最后输出结果就是平的，分不出层次。
正确写法是在每一层开头取一次size，然后在这个size范围内做循环：
python复制size = len(queue)
for _ in range(size):
node = queue.popleft()
process(node)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
这样queue的长度在循环过程中会变化，但循环次数已经固定成当前层的节点数。我在实际刷题中踩过的坑，就是在循环里直接把左右孩子追加进同一个队列，忘记先取size，结果把两层数据混在一段里。后来我给自己定了一个规矩：写BFS的代码，第一行永远是先取size，永远不要直接拿while queue做层控制。
2.3 二叉搜索树：中序遍历自带顺序
二叉搜索树相关的题目，在这个区间里往往有两道，一类是找第K小的节点，一类是验证一棵树是不是合法的二叉搜索树。这两种题有一个共同的钥匙：中序遍历。因为二叉搜索树的中序遍历结果一定是严格递增的，这个性质比节点值大小还要好使。
找第K小的问题，做法就是中序遍历，维护一个计数器，当计数器等于k时，当前节点就是答案。这里可以用递归写法，也可以改成迭代写法用显式栈。如果树的深度很大，递归可能栈溢出，迭代栈更稳。
验证二叉树是否合法，最常见的错误写法是只比较当前节点和左右子节点的值。我一开始就犯过这个错，结果是某个测试用例左子树里藏了一个比根还大的节点，局部看每个父子关系都成立，但整棵树并不合法。正确做法是维护一个取值区间，递归左子树时把区间右边界收紧为当前节点值，递归右子树时把区间左边界提升为当前节点值。中序验证法也可以，用前一个节点的值做比较：
python复制prev = None
def inorder(node):
nonlocal prev
if not node:
return True
if not inorder(node.left):
return False
if prev is not None and node.val <= prev:
return False
prev = node.val
return inorder(node.right)
注意这里的判断是node.val <= prev，不是小于。因为二叉搜索树要求严格递增，存在重复值就不合法。这个等号就是我曾经漏掉的细节，一漏就错了一个测试点，特别亏。
3. 动态规划：别急着写递推，先把“状态”说人话
3.1 状态定义决定了你这题能不能写对
这段题目里的动态规划，几乎没有那种一眼就能看出来的签到题，反倒是几个经典模型的变体。我踩过最大的坑，就是一上来先背转移方程，而不是先把dp数组的含义定义明白。
比如求最长子数组和之类的问题，dp[i]通常表示“以第i个元素结尾的连续子数组的最大和”。如果这样定义，答案就不能直接返回dp[n]，因为你可能不需要包含最后一个元素。正确做法是边填表边维护一个全局最大值，最后输出这个最大值。
但有些题又不一样，比如求编辑距离，dp[i][j]表示的是“字符串A前i个字符变成字符串B前j个字符需要的最少操作次数”，这种情况下答案就是dp[n][m]。同样是二维数组，一个返回最大值，一个返回最终格，差别全在状态定义上。我建议你写DP前先问自己一个问题：这个dp[i]或dp[i][j]，
它到底是以谁结尾，还是表示前多少个元素的答案？这个没想清楚，后面所有代码都是在揣摩测试用例，而不是在解题。
3.2 举一个二维DP的例子：编辑距离
编辑距离是Hot100里的常客，它特别适合用来理解二维DP的转移方向。题目会让你在两个字符串之间做三种操作：插入、删除、替换，问最少几步能让两个字符串相等。
我的理解方式是把三种操作分别对应到三个格子：
- 从dp[i-1][j]加1，相当于删掉字符串A的第i个字符；
- 从dp[i][j-1]加1，相当于给字符串B插入一个字符，让当前这一位匹配；
- 从dp[i-1][j-1]加1，相当于把A的第i个字符替换成B的第j个字符。
如果两个字符本来就相等，那就不需要操作，直接继承dp[i-1][j-1]。
转移方程写出来就是：
python复制if a[i] == b[j]:
dp[i][j] = dp[i-1][j-1]
else:
dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1
很多人背会了这个公式，但换个题就不会写，原因是没有真正理解三个来源分别代表什么动作。你在纸上把“删除、插入、替换”三个动作各演一遍，把这个表格手填两三行，它就不再是一个需要硬背的公式了。
3.3 我常用的手工填表法
刷DP题时，我有个特别笨但特别有效的习惯：在正式写代码前，先用小样例在纸上填一遍表。以两个字符串为例，我会先画出一个二维表格，第一行表示空串对目标串的距离，第一列表示源串对空串的距离，这两个初始化值是必须明确的：空串变成任意长度为j的串，需要j次插入操作。这个初值如果没写对，后面整张表都会偏移。
手工填表的另一个作用，是帮你确认遍历方向。比如最长回文子序列这种题，dp[i][j]依赖dp[i+1][j]和dp[i][j-1]，那你就不能简单地让i从小到大遍历，因为计算dp[i][j]时，dp[i+1]那一行还没有被算出来。我在纸上把依赖关系画出来之后，立刻就知道i必须从n-1往0倒着遍历，j从i+1往n-1正着遍历。这个方向判断，比任何记忆都可靠。
3.4 递归爆栈：别让好思路死在系统栈上
动态规划可以用递归加备忘录，也就是所谓记忆化搜索，也可以用迭代方式自底向上填表。这两个思路等价，但实际运行时差别很大。Hot100(71-80)里有的题目数据规模能到十万级别，递归加备忘录一旦调用深度超过系统限制，就会直接栈溢出。我在某个子序列题目上就栽过这个跟头：思路完全对，结果用递归写出来提交后崩溃，改成迭代填表后一次通过。
不是递归慢，而是系统默认允许的递归深度有限。所以在写代码之前，你先估算一下递归深度大概多少。如果深度可能超过一万，我建议直接动手写迭代版本。这个选择在面试里也很加分，因为你能主动考虑到工程上的限制，而不是只停留在算法正确性。
4. 回溯和搜索：模板简单，剪枝才见真功夫
4.1 回溯模板：选进去，递归，撤销
回溯题在这一段大概有两道，最常见的是子集、组合、排列这类问题，还有一种是在网格上做路径搜索。回溯的核心思想是暴力枚举所有可能，但通过剪枝避免无效分支。我写回溯早就形成固定模板了：
python复制def backtrack(path, choices):
if 满足结束条件:
记录结果
return
for i in range(len(choices)):
做选择
backtrack(path, choices)
撤销选择
这个模板里最容易写错的地方，是“撤销选择”。很多新手会忘记在递归返回之后把状态恢复成原样，导致下一个分支看到的还是上一分支残留的标记，结果输出一堆错乱的结果。我给自己定的规矩是：回溯函数的开头做了什么修改，函数返回之前就必须把对应状态改回来，这一点没有例外。
4.2 重复结果怎么去：排序加同层跳过
如果题目给的数组里本身有重复元素，子集和排列的答案就需要去重。一种常见做法是先排序，让相同的元素聚在一起，然后在同一层遍历时，如果当前元素和前一个元素相等，并且前一个元素还没有被用过，就跳过这个分支。
代码里通常长这样：
python复制nums.sort()
visited = [False] * len(nums)
def dfs(depth):
...
for i in range(len(nums)):
if visited[i]:
continue
if i > 0 and nums[i] == nums[i-1] and not visited[i-1]:
continue
visited[i] = True
dfs(depth + 1)
visited[i] = False
为什么是not visited[i-1]而不是visited[i-1]？我最初也搞错过。后来理解到：如果前一个相同元素已经在本次递归路径中被使用了，那当前元素继续使用是允许的，这是一种合法情况；如果前一个元素没被使用，说明在同一层已经跳过了一个相同值，再选当前值就会生成重复序列。这个条件记住之后，重复排列的问题基本不会再错。
4.3 网格搜索的四个方向与访问标记
网格类的搜索题也是回溯的常见变体，比如在一个二维字符矩阵里找某个单词路径。它的搜索空间是上下左右四个方向，每次进入相邻格子前，必须判断是否越界、字符是否匹配、是否已经访问过。
我踩过的一个高频坑是访问标记的时机。递归写法必须在进入递归之前就把当前格子标记为已访问，防止从另一个方向再次走进这个格子。如果递归完再撤销标记，那是正常的回溯操作。但如果你用BFS写法，标记的时机是在节点入队时，而不是出队时。道理很简单：一个节点可能被多个邻居同时发现，如果等出队才标记，它会被重复加到队列里，既浪费时间还可能死循环。这个细节在“岛屿数量”这类题里尤其明显，我曾在BFS里少写了一个入队标记，结果同一个岛屿被统计了好几次。
5. 现场拆解：三道典型题的完整脑回路
5.1 网格上的单词搜索：回溯加坐标剪枝
这类题可以抽象成：给定一个二维网格和一个单词，问能不能在网格中找出一条连续路径，使得路径上的字符正好组成这个单词。我第一次拿到题，第一反应是把每个格子当起点暴力DFS，确实能通过样例，但会挂在长单词和大网格的组合上。
标准解法是用回溯。先遍历每个格子作为起点，如果当前格子的字符不等于单词第一个字符，直接跳过，没必要进递归。如果相等，进入DFS函数，当前位置坐标和当前匹配到的单词下标都传进去。每次递归前把当前格子标记为已访问，然后往四个方向走；四个方向都不行就回溯，把标记还原。
复杂度要心里有数：O(mn3^L)，其中m和n是网格长宽，L是单词长度。为什么不是4的L次方？因为从第一个字符进入之后，后续每一步最多只有三个方向可选，回头的方向已经被自己刚才的访问标记挡住了。
还有一个剪枝技巧，在比较极端的用例里能救命：先统计网格里所有字符的出现频次，再统计单词里每个字符的频次。如果单词里某个字符的数量比网格里还多，那这个单词根本不可能存在，直接返回false，连DFS都不用跑。我在单词特别长的用例上试过，这个剪枝能省下大量时间。
5.2 最长回文子序列：二维DP的方向陷阱
回文类DP是我认为Hot100(71-80)里最值得手写一遍的题目类型。以最长回文子序列为例，dp[i][j]表示字符串从第i个位置到第j个位置之间，能构成的最长回文子序列长度。当两端字符相等时，可以在中间结果上再加2；不等时，取去掉左端和去掉右端两种情况里的较大值。
转移方程很清晰，但遍历方向特别容易错。因为计算dp[i][j]时依赖dp[i+1][j-1]、dp[i+1][j]和dp[i][j-1]，这三个格子分别位于当前格子的左下、下方和左方。如果i从小往大遍历，计算左侧时右侧可能还没算晚。我用一个简单例子验证了一下，发现必须让i从n-1倒着遍历，j从i+1正着遍历，才能保证所有依赖格都已经计算完。
这种题没有太多的巧妙优化，它考的就是你有没有真的理解二维数组填表顺序。我在纸上把依赖关系画成箭头之后，再也没错过遍历顺序。如果你也经常在回文DP上搞混方向，我强烈建议你试试这个小动作，比死记“i倒着j正着”要有用得多。
5.3 直方图最大矩形：单调栈的经典应用
直方图最大矩形这道题，第一次见会觉得无从下手，因为它既要考虑高度，又要考虑宽度，还不能简单枚举每一对左右边界。我最早是用双重循环枚举区间的最小高度，复杂度O(n^2)，在数据量过万时就超时了。
正确做法是单调栈。核心思路是：对于每个柱子，找到它左边第一个比它矮的柱子和右边第一个比它矮的柱子，这两个位置之间的距离，就是“以这个柱子高度作为矩形高度”时能取到的最大宽度。为了在一次遍历里同时找到左右边界，我们可以维护一个高度递增的栈。栈里存的是下标，不是高度，这样才能计算宽度。
我习惯在heights数组首尾各补一个0，作为哨兵：
python复制def largestRectangleArea(heights):
heights = [0] + heights + [0]
stack = []
area = 0
for i in range(len(heights)):
while stack and heights[stack[-1]] > heights[i]:
h = heights[stack.pop()]
w = i - stack[-1] - 1
area = max(area, h * w)
stack.append(i)
return area
补0的最大好处是省掉边界判断。末尾的0会让栈里所有非零高度的柱子最终都弹出一次，首部的0又能充当左边界，让宽度计算时不需要单独判断栈是否为空。我第一次把代码里的>写成>=时也过样例，但>更符合“找第一个更矮柱子”的语义，如果高度相等，不急着弹栈也能在后面得到正确的最大面积。这个细节不致命，不过统一成>之后思路更干净。
6. 常见问题速查与避坑清单
6.1 样例能过但提交超时
我刷Hot100(71-80)时遇到最多的问题就是“本地测样例一切正常，一提交就超时”。这种时候我会按下面这个顺序排查：
先看是不是有重复计算。递归回溯里最常见的超时原因是少了剪枝，或者访问标记加晚了。再看是不是数据规模判断错了，比如你写了O(n^2)的算法，但n已经到了一万以上。还要检查字符串切片是不是用得太多，Python里的切片会复制字符串，循环切片在长字符串上代价很高。
网格搜索题如果超时，优先考虑是不是访问标记没有及时生效，导致同一个格子被反复进入。我曾经在一个四方向DFS里把标记放在递归出口，结果每次回溯到上一层，下一层又能走回这个格子，复杂度直接指数爆炸。
6.2 结果差一点：差1或差2的原因
如果你提交后返回的结果只和答案差一点点，比如差1，基本可以断定是边界初始化的问题。差1的常见背景包括：dp数组长度设成了n，但你实际访问了第n个下标，导致只能开成n+1；或者dp[0]的初始值和真实含义差了一个偏移。
差2的情况往往出在回文类或者区间类DP上。比如单独一个字符的子序列长度应该是1，但如果你忘了初始化dp[i][i]=1，后面合出来的长度会整体偏小。我在最长回文子序列这道题上，就是因为漏了这个对角线初始化，总是比正确答案少1到2。
还有一个我很早就踩过的坑：一维DP求最值的时候，答案不是dp的最后一个元素，而是dp数组里的最大值，或者是一个随遍历更新的全局变量。这个问题在最长子数组和那一类题里特别常见。
6.3 链表和树的空指针与环
链表题最容易出现的提交错误是空指针和死循环。空指针往往是没判空导致的，我写链表递归和迭代的第一步都是判空，这已经是肌肉记忆了。快慢指针的循环里，要同时判断fast和fast.next是否为空，少判断一个都有可能空指针。
成环的问题则多半出在重排链表这类题。切半之后如果没有把前后两段断开，交错合并时就会形成环，导致输出超时。我给自己立的规矩是：只要切了链表，切开的那个next就必须改成None，除非题目明确要求保留原链表结构。
树相关的空指针也常见，尤其是递归遍历时没有先处理空节点。写递归的第一步永远是if not node: return对应值，这是树的通用前置动作。验证二叉搜索树的题里，还有人因为只判断当前节点和子节点，把全局非法结构漏掉了。解决方式就是我在2.3里说的，要么维护上下界，要么用中序遍历的前驱节点比较。
6.4 我的两遍刷题法
第二遍刷Hot100(71-80)时，我采用了一套更高效的安排，也分享给你。第一遍按原始顺序做，每道题限时最多40分钟，想不出来就直接看题解，但要允许自己“抄作业”。这里的抄作业不是单纯拷贝代码，而是边看边在纸上画解法流程，看完之后合上答案自己重写一遍。第二遍我完全不看原始顺序了，而是按“链表重排、树层序变体、子序列DP、单调栈、网格回溯”几个专题重新归组，每个专题找三五道同类题一起做，目的就是训练模式识别。
两轮之后，我会在草稿纸右上角标注每道题的一句话考点。直到现在，我做新题遇到卡壳时，还会翻一翻这些角标，用来提醒自己曾经在哪类模型上栽过跟头。这个方法对我帮助特别大，我从Hot100前几段一路刷过来，真正的质变就是发生在这个区间。
我个人的体会有两点。第一，Hot100(71-80)最适合用来练“模式识别”，而不是练冷门技巧；你刷完这一整段之后，能不能在见到一道新题的五分钟内判断出它是链表、树、DP还是回溯，远比记住单个题目的代码重要。第二，做完题后花十分钟用一句话写下考点和易错点，这道题才算真正结束。把这句话留在草稿纸右上角，第二轮复习时只看这些角标，效率会高很多。如果你正在刷这一段，建议先把链表重排、树层序变体、子序列DP、单调栈这四个模型写熟，再碰综合题，会顺畅很多。