逆流而上的小船1. 一道“看似很简单”的题，为什么能难住这么多人
“盛最多水的容器”是LeetCode上的一道经典算法题，编号11。我第一次见到这道题的时候，第一反应是：这不就是一个找最大面积的问题吗，遍历所有组合不就完事了？但真当我去写代码，面对一个长度为几万的数组时，暴力解法的O(n²)复杂度立刻让我清醒了——这题的难点不在于“能不能做出来”，而在于“能不能在面试官预期的时间内做出来”。
题目本身描述得非常生活化：给定n个非负整数a1, a2, ..., an，每个数代表坐标中的一个点(i, ai)。在坐标内画n条垂直线，垂直线i的两个端点分别是(i, ai)和(i, 0)。现在要找出其中的两条线，使得它们与x轴共同构成的容器可以容纳最多的水。
换句话说，给定一个整数数组height，返回其中两条线（即两个索引对应的两个高度值）与x轴构成的容器最多能容纳多少水。容器的容量由两条线中较短的那条决定，因为你不能倾斜容器，水超过矮的那条边就会溢出来。
1.1 题目的本质：区间最值问题
这道题虽然表面上看是一个“几何面积”问题，但本质上是一个区间最值问题：在数组中选择两个索引i和j（i < j），使得min(height[i], height[j]) * (j - i)的值最大。
这里的min(height[i], height[j])是容器的高度，(j - i)是容器的宽度。我们需要找到让这个乘积最大的那对索引。
为什么说它难？因为数组长度可能达到10^5量级，如果直接枚举所有索引对，复杂度是O(n²)，在数据量大时完全不可行。这也是面试官考查这道题的真正用意——他们不是在检验你会不会算面积，而是在检验你能否在暴力解法的基础上，找到更优的优化思路。
1.2 大多数人的第一直觉：暴力枚举
我第一次尝试这道题时，老老实实地写了个双重循环：
python复制def maxArea(height):
n = len(height)
max_water = 0
for i in range(n):
for j in range(i + 1, n):
area = min(height[i], height[j]) * (j - i)
max_water = max(max_water, area)
return max_water
这个解法逻辑上完全正确，思路也非常直接：把所有可能的组合都试一遍，记录最大值。但在LeetCode的测试用例下，当数组长度达到10^5时，这个代码会在超时边缘疯狂试探，甚至直接超时。
实际上暴力法的时间复杂度是O(n²)，空间复杂度O(1)。在面试或笔试场景下，这个复杂度一般是过不了关的。但暴力法的价值在于——它能帮我们验证优化解法的正确性。我在实际写双指针解法时，就会先用暴力法跑几个随机小数据，验证一下优化解法的结果是否与暴力法一致。这个习惯在刷题阶段帮我避开了很多“自以为对但实际不对”的坑。
那么问题来了：如何把O(n²)降到O(n)？这就是双指针法登场的时机。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 双指针解法：为什么移动较矮的那条线是安全的
双指针法的核心思路非常简洁：用两个指针分别指向数组的两端，逐步向中间移动，在移动过程中不断更新最大面积。
但这里有一个关键问题：每次移动哪个指针？答案是——移动指向较矮线段的那个指针。为什么？这需要从数学上严格证明，而不是凭直觉“猜”出来的。
2.1 单调性的本质：面积由短板决定
我们先看一个具体的例子。假设数组是[1,8,6,2,5,4,8,3,7]，两个指针分别指向左端index=0（高度1）和右端index=8（高度7）。此时容器的容量是：
code复制min(1, 7) * (8 - 0) = 1 * 8 = 8
现在我们要决定移动哪个指针。如果我们移动较矮的左指针（index=0到index=1），新的容器容量是：
code复制min(8, 7) * (8 - 1) = 7 * 7 = 49
容量变大了。但如果换个场景，移动较矮的指针之后容量可能还是变小，这都没关系——关键在于：我们移动较矮指针后，绝不会错过那个可能成为最优解的组合。
为什么？这里需要理解一个关键逻辑：当前状态是左指针指在i，右指针指在j，并且height[i] < height[j]。此时容器的容量是height[i] * (j - i)。
现在我们思考一个问题：如果保持左指针i不动，把右指针j向左移动（即j-1, j-2, ...），能不能得到比当前更大的容量？
答案是：不能。因为无论右指针移到哪个位置k（i < k < j），新的宽度(k - i)一定小于(j - i)，而新的高度一定是min(height[i], height[k])。由于height[i] < height[j]，我们根本不需要知道height[k]的值——无论height[k]是多少，min(height[i], height[k])最多等于height[i]，不可能超过height[i]。
也就是说，如果固定左指针i不动，右指针无论怎么向左移动，容器的高度不可能超过height[i]，宽度还在不断减小，所以面积不可能超过height[i] * (j - i)，也就是当前面积。
结论就是：以索引i为左边界的最优解，已经在这个状态下被取到了。所以我们可以放心地把左指针向右移动，把i这个位置从候选中排除，因为它已经不可能贡献更大的面积了。
2.2 每一步都在缩小区间，但不会错过最优解
这个证明的核心思想，其实就是数学归纳法里常见的“排除法”：每次移动较矮的指针，本质上是“排除掉一个不可能产生最优解的状态”。
用更直观的话来说：假设全局最优解是下标a和b（a < b）对应的两条线。在双指针移动的过程中，当左指针第一次到达a时，右指针一定还在b的右边（因为右指针从数组最右端出发，且a < b）。此时有两种情况：
- 情况一：左指针停在a后，右指针继续向左移动，直到到达b。在这个过程中，只要左指针一直是两根指针中较矮的那根，左指针就不会动，右指针最终会到达b。当右指针到达b时，我们就能计算出最优解，并记录下来。
- 情况二：左指针到达a后，如果右指针还没到b，但右指针比左指针矮，那么右指针会停下来，左指针会继续向右移动。但这会不会导致错过最优解？不会，因为此时右指针指向的位置在b的右边，且
height[右指针] < height[a]。这时以右指针和a构成的面积是height[右指针] * (右指针 - a)，而它一定小于等于height[a] * (b - a)吗？不一定，因为height[右指针]可能比height[a]小很多，但(右指针 - a)更大，乘积不一定更小。
这里我需要再严谨一点：实际上有一个更简单的证明方法——双指针算法本质上是在枚举所有可能的“较矮边”。每次移动较矮的指针后，新指针指向的位置在未来的某个时刻，有可能会成为最优解中较矮的那条边。而任何一个位置，作为“较矮边”的最优情况，一定是在它与尽可能远的另一边配对时取得的。由于双指针是从两端往中间收的，所以当某个位置作为较矮边时，与它配对的另一边就是当前能取到的最远位置。这样一来，当它作为较矮边的情况被“处理”完之后，就可以安全地排除掉了。
2.3 官方双指针的伪代码与直观理解
双指针法的标准实现非常简单：
python复制def maxArea(height):
left, right = 0, len(height) - 1
max_water = 0
while left < right:
width = right - left
h = min(height[left], height[right])
max_water = max(max_water, width * h)
if height[left] < height[right]:
left += 1
else:
right -= 1
return max_water
从代码上看，这个过程就像两个指针在“夹逼”整个数组：每轮迭代排除掉当前较矮的那一端，同时更新一次面积。整体上每个元素最多被访问一次，时间复杂度O(n)，空间复杂度O(1)。
我在给别人讲这道题的时候，喜欢用一个“开会抢座位”的类比：数组两端坐着两个人，他们中间夹着一个容器。每次我们从两端中较矮的那一侧往里挪一步，是因为这一侧“已经发挥不出更大的作用了”——它最高的容量上限已经被当前状态锁定了。把座位让给下一个人，看看下一个人的加入能不能让容器装更多的水。
3. 从暴力到双指针：代码实现与边界陷阱
理论证明说完，实际写代码的时候还会遇到一些细节问题。很多人在LeetCode上提交双指针解法后，发现某些测试用例过不了，或者在某些变体题目里用错规则，其实就是这些细节没吃透。
3.1 代码实现的几个细节
第一个细节是指针移动时何时更新面积。我见过有些初学者先移动指针再计算面积，导致漏掉了初始状态下两端构成的容器。正确的顺序是：先计算当前left和right构成的面�，更新max_water，再移动指针。这一点看起来非常基础，但实际写代码时很容易犯。
第二个细节是当height[left] == height[right]时怎么办。很多实现里用的是if height[left] < height[right]: left += 1 else: right -= 1，也就是相等时移动右指针。但实际上移动哪边都无所谓，因为此时两边高度相等，无论移动哪一边，都不会影响“排除不可能状态”的正确性。甚至可以两边同时移动（left += 1; right -= 1），因为当两条边相等时，以这两条边为边界的最大容器已经被记录了，同时排除两边也是安全的。不过为了代码简洁，多数标准答案只移动一边。
第三个细节是数据类型的溢出问题。计算width * h时，如果数组长度很大（比如10^5），高度也很大（比如10^9），乘积可能超过32位整型范围。在Python里这不成问题（整数可以无限大），但如果你用C++或Java写，需要用long long或long类型来存储面积。我之前在LeetCode评论区看到有人用int类型过不了几个测试用例，就是因为溢出导致答案错误。
3.2 如何验证双指针解法的正确性
如果你和我一样，第一次接触双指针时觉得“这个证明有点绕”，一个非常实用的小技巧是：写一个暴力解法作为对照，然后生成随机数组进行验证。这个方法在我刷题时帮了大忙。
python复制import random
def max_area_brutal(height):
n = len(height)
max_water = 0
for i in range(n):
for j in range(i + 1, n):
max_water = max(max_water, min(height[i], height[j]) * (j - i))
return max_water
def max_area_two_pointer(height):
left, right = 0, len(height) - 1
max_water = 0
while left < right:
max_water = max(max_water, min(height[left], height[right]) * (right - left))
if height[left] < height[right]:
left += 1
else:
right -= 1
return max_water
# 随机生成1000组测试数据
for _ in range(1000):
arr = [random.randint(0, 20) for _ in range(random.randint(1, 20))]
if max_area_brutal(arr) != max_area_two_pointer(arr):
print("出错了！", arr)
break
else:
print("所有随机测试通过")
这个方法的核心价值在于：你不需要完全理解证明，就能通过实验验证算法的正确性。当然，我建议还是要把证明搞懂，因为面试官可能会追问“为什么移动矮的指针是安全的”，这时候光说“我试过没问题”是不够的。
3.3 几个容易写错的变体
这道题还有一个常见变体是要求返回两条线的索引而不是面积。这时在更新max_water时，需要额外记录对应的left和right值。要注意的是：当你记录了一组索引后，后续即使出现了相同的面积，也不要更新索引（除非题目明确要求返回任意一组）。因为按照题目的隐含语义，通常返回最先找到的那组或者任一组都可以，但如果要返回面积最大的那一组，且答案唯一的话，保留第一次出现的最大值即可。
另一个变体是容器高度可以为0时怎么处理。height[i] = 0意味着该位置没有线段，不能装水。这对算法没有影响——min(0, x) * width = 0，仍然按照正常规则计算面积即可。但如果用暴力法，你可以加一个剪枝：只有height[i] > 0且height[j] > 0时才计算面积，降低常数因子。双指针法不需要这个剪枝，因为每轮都必须移动指针。
4. 从这道题看“相向双指针”的通用框架
刷题刷多了就会发现，“盛最多水的容器”只是“相向双指针”这一大类问题的入门题。相向双指针的使用场景非常广泛，包括但不限于：有序数组的两数之和、反转数组、判断回文串、三数之和等。理解这道题的证明逻辑，对于掌握整个相向双指针家族都有帮助。
4.1 相向双指针的三种典型模型
我根据自己的刷题经验，把相向双指针分成三种典型模型：
第一种是对撞模型：两个指针从两端向中间逼近，直到相遇。典型题目就是“盛最多水的容器”和“有序数组的两数之和”。这种模型的核心特征是：有一个明确的“夹逼”条件，每一步可以安全地排除掉一个端点。
第二种是滑动窗口模型：实际上是同向双指针，两个指针都从起点出发，右指针负责扩展窗口，左指针负责收缩窗口。典型题目是“无重复字符的最长子串”和“最小覆盖子串”。这种模型和相向双指针的区别在于，两个指针的运动方向相同，且窗口始终是连续的子数组。
第三种是快慢指针模型：两个指针以不同速度移动，用于检测链表环等场景。
“盛最多水的容器”属于第一种对撞模型。它与其他对撞题的区别在于：它不是要求找到一个特定的值（如两数之和的target），而是要求找到全局最大值。这决定了它的移动规则不依赖于“当前和与target的比较”，而是依赖于“当前两条边的高低比较”。
4.2 怎么判断一道题适不适合用相向双指针
我在实际做题时总结了两个判断条件。第一，问题的解可以表示为“两个索引的组合”，即你最终要找的答案是数组中两个位置的关系（距离、区间、配对值等），而不是单个位置的值。第二，当固定其中一个索引时，另一个索引存在单调的最优移动方向。
以“盛最多水的容器”为例：固定左指针后，右指针向左移动时面积不可能超过当前面积（因为宽度减小且高度受限于较矮边），所以右指针只有可能向右移动才对寻找更优解有帮助——但右指针已经是最右端了，不能向右，所以固定左指针时右指针已经处于最优位置。于是只能移动左指针。这就形成了“每次移动较矮边”的单调规则。
再以“有序数组的两数之和”为例：固定一个指针后，根据当前和与目标值的大小关系，另一个指针的移动方向是确定的——和大了就把右指针左移，小了就把左指针右移。这也是单调性。
如果你在分析一道题时，发现不存在这种“固定一个后另一个方向单调”的性质，那大概率不能用相向双指针，需要另寻他路。
4.3 双指针的时间复杂度为什么是O(n)而不是O(n²)
很多人会疑惑：两个指针从两头往中间走，每轮移动一个指针，总共不是要走n步吗？确实，总步数是n-1步左右，所以时间复杂度是O(n)。虽然表面上看，每一轮都只移动了一个指针，但整体上每个元素最多被一个指针“遍历”一次，不存在重复遍历，所以总操作次数就是O(n)。
这个和暴力解法的O(n²)有本质区别：暴力法是把所有可能的(i,j)组合都试一遍，而双指针法是“排除掉所有不可能成为最优解的组合”，只检查了O(n)个关键候选。
我特别喜欢这个“排除”视角，因为很多一开始理解不了双指针的人，一旦接受“排除法”的思路，后续遇到类似的优化问题（比如接雨水、柱状图中最大的矩形），思路会开阔很多。
5. 从“盛最多水的容器”到“接雨水”：同一个思想在不同题中的应用
如果你刷LeetCode，一定知道题号42的“接雨水”可以说是“盛最多水的容器”的姊妹题。两道题的场景几乎一样：给定一个数组，表示柱子的高度，计算能接多少雨水。但解法思路却截然不同——这恰好说明了“理解题型之间的差异比背题更重要”。
5.1 两道题的对比：一个找“容器”，一个算“填充”
“盛最多水的容器”要求的是两条柱子之间能装的最大水量，换句话说，我们只关心一个孤立的容器，它由两条柱子构成，不考虑柱子之间其他高低起伏的影响。而“接雨水”要求的是整个凹槽区域内能接的雨水总量，需要考虑每一条柱子之间的空隙。
这两道题的核心区别在于：前者的面积由两条边中较矮的那条决定，后者的每个位置能接的雨水量由它左右两侧“最高柱子”中较矮的那根与当前位置柱子的高度差决定。
正是这个区别，导致两道题的解法完全不同。“盛最多水的容器”用双指针从两端夹逼；“接雨水”可以用动态规划（预处理左右最大值）、单调栈或双指针（在配合left_max和right_max的前提下）来实现。
有意思的是，“接雨水”也有一种双指针解法，但它并不是简单地“移动较矮边”，而是需要通过维护left_max和right_max来判断当前位置能接多少水。我第一次用“盛水容器”的双指针逻辑去套“接雨水”时，直接写错了——这也是为什么我建议刷题时要理解每道题的数学结构，而不是背模板。
5.2 “柱状图中最大的矩形”与单调栈
同样描述“矩形面积”的还有题号84的“柱状图中最大的矩形”。给定一个非负整数数组表示柱状图中各个柱子的高度，求在该柱状图中能够勾勒出来的矩形的最大面积。
注意这道题和“盛最多水的容器”有本质区别：前者用两条柱子作为容器边界，中间不一定填满；后者要求的是柱状图内部的一个矩形，矩形的顶边必须是平的，且矩形必须完全由柱子包围，不能悬空。
换句话说，“盛最多水的容器”允许跳过中间的不规则柱子，而“柱状图中最大的矩形”不允许跳过——它要求矩形内的所有位置上，柱子高度至少达到矩形的顶边高度。
因此这道题需要用单调栈来解，对每个柱子作为矩形高度的“瓶颈”时，找到左右两侧第一个比它矮的柱子。单调栈的复杂度是O(n)，但这道题的思维难度明显高于前两道。
5.3 为什么刷题不能只记模板
我见过很多人刷题有一个误区：碰到一个题，觉得“这跟双指针那题有点像”，就套双指针；觉得“这跟接雨水那题有点像”，就套单调栈。结果碰到“柱状图中最大的矩形”，因为模板套不进去，就卡住了。
我的建议是，在刷每一道题时，都问自己三个问题：
- 这个问题的最优解可以用什么数学结构描述？（是“区间上的最大值”还是“每个位置的累加值”？）
- 这个问题的约束条件决定了什么解法？（是“只找两个端点”还是“要考虑所有内部位置”？）
- 如果暴力解法和优化解法同时存在，优化解法优化掉了哪部分重复计算？
就拿“盛最多水的容器”来说，双指针之所以有效，是因为它每次排除掉一个端点，而每个端点作为“较矮边”的最优值只出现一次。理解了这一点，你在面对任何“两个指针夹逼”的问题时，都能快速分析出移动规则，而不是死记硬背“矮的往中间走”。
6. 深入一点：还有没有比双指针更优的解法？
在LeetCode的题解区，偶尔会看到有人问：双指针已经是O(n)了，还有没有更快的算法？理论上，任何基于比较的算法都需要至少O(n)的时间来读取所有输入，所以O(n)已经是渐进最优的复杂度下限了。
但如果你考虑实际运行时间，还能做哪些常数级别的优化？我实际验证过几个方向：
第一个方向是提前终止。如果当前左右指针中较矮的那一边，其高度乘以数组总长度已经小于等于当前最大值，那么后续无论怎么移动，面积都不可能超过当前最大值，可以直接退出循环。
python复制def maxArea_early_stop(height):
left, right = 0, len(height) - 1
max_water = 0
n = len(height)
while left < right:
h = min(height[left], height[right])
width = right - left
max_water = max(max_water, h * width)
# 如果当前较矮边高度乘以数组最大跨度已经无法超过max_water，提前终止
if h * n <= max_water:
break
if height[left] < height[right]:
left += 1
else:
right -= 1
return max_water
这个优化在高度值普遍较小的测试数据中效果明显，但在随机大数测试中提升有限。因为h * n大于max_water的情况非常普遍，循环很少能提前退出。
第二个方向是跳过连续较矮的柱子。如果左指针向右移动时，下一个位置的高度比当前左指针还矮，那么移动后的容器高度一定不会增加（容器高度由较矮边决定），宽度还在减少，所以面积必然减少。我们可以直接跳过这些“必然变差”的位置。
python复制def maxArea_skip(height):
left, right = 0, len(height) - 1
max_water = 0
while left < right:
h = min(height[left], height[right])
width = right - left
max_water = max(max_water, h * width)
if height[left] < height[right]:
# 跳过所有比当前左指针矮的位置
next_left = left + 1
while next_left < right and height[next_left] <= height[left]:
next_left += 1
left = next_left
else:
# 跳过所有比当前右指针矮的位置
next_right = right - 1
while next_right > left and height[next_right] <= height[right]:
next_right -= 1
right = next_right
return max_water
这个优化在数组中有大量低谷的时候非常有效——那些明显不可能成为边界的矮柱子会被直接跳过，减少了多次无效的min运算和乘法运算。我在本地跑过一些极端用例，比如严格递增数组和严格递减数组，这个优化版本的循环次数从n次降到了约n/2次，运行时间大约提升30%到50%。
但这些优化本质上都属于“常数优化”，不改变O(n)的渐进复杂度。在面试中，除非面试官主动问“还能不能优化”，否则不建议主动写这些花活——因为逻辑复杂度上去了，反而容易引入bug。
6.1 与“最多能接多少水”相关的数学延伸
如果你对这道题的数学背景感兴趣，可以了解一下极大极小理论和割集理论。从图论的角度看，数组可以看作一个边权线性函数的特殊情况，找最大容器等价于在某个代价函数下找全局最优割集。
不过对于绝大多数面试和笔试场景，这些数学延伸并不需要掌握。我更推荐的做法是：把这道题当做一个“窗口”，通过它去理解双指针的思想，然后刷至少10道不同变体的双指针题，形成自己的方法体系。
7. 实操经验：我实际跑过的测试用例和从中学到的教训
最后分享一些我在实际做题和帮别人 review 代码时积累的经验，这些内容在标准题解里通常不会写，但对真正理解这道题很有帮助。
7.1 经典边界用例
我每次讲这道题，一定会用这几个测试用例来验证代码：
| 输入数组 | 预期输出 | 关键点 |
|---|---|---|
| [1,1] | 1 | 最小规模，只有两个元素时直接返回min(a,b)*1 |
| [1,2,1] | 2 | 两个1在两端，中间2是障碍但不影响结果 |
| [4,3,2,1,4] | 16 | 两端都是4，中间再高也没用 |
| [1,8,6,2,5,4,8,3,7] | 49 | LeetCode官方示例，考察双指针路径 |
| [2,3,4,5,18,17,6] | 17 | 最大值在中间偏后，验证指针交汇路径 |
| [10,9,8,7,6,5,4,3,2,1] | 25 | 严格递减数组，双指针需要一直移动左指针 |
严格递减数组这个用例很有代表性。比如[10,9,8,7,6,5,4,3,2,1]，双指针的移动过程是：left=0, right=9，面积=min(10,1)*9=9；因为height[left] > height[right]，移动right；right=8，面积=min(10,2)*8=16；移动right；right=7，面积=min(10,3)*7=21；移动right；right=6，面积=min(10,4)*6=24；移动right；right=5，面积=min(10,5)*5=25；移动right；right=4，面积=min(10,6)*4=24；移动right；right=3，面积=min(10,7)*3=21；移动right；right=2，面积=min(10,8)*2=16；移动right；right=1，面积=min(10,9)*1=9；移动right。最终最大值25出现在right=5时。整个过程正好能看出“右指针一直移动，左指针从未移动”的极端路径。
7.2 容易踩的坑：相等元素与跳出条件
如果一个数组里所有元素的高度都相等，比如[5,5,5,5,5]，双指针会怎么走？left=0, right=4，面积=54=20；移动right（因为相等时用else分支），right=3，面积=53=15；移动right，right=2，面积=52=10；移动right，right=1，面积=51=5；移动right，right=0，循环结束。最大面积20，也就是最两端的两个5构成的容器。这个答案显然是正确的——在所有高度相同的数组里，最宽的两个元素构成的容器面积最大。
另一个容易踩的坑是while循环的终止条件。标准写法是while left < right，不是while left <= right。如果用后者，当left和right相等时，width=0，面积=0，计算没有意义，而且某些实现里可能会因为数组越界或死循环而出错。我在review别人代码时经常看到这个错误。
7.3 面试中的追问与回答策略
如果你在面试中遇到了这道题，面试官通常会有几个追问方向。第一个是：“为什么移动矮的指针是对的？”这是一个证明题，需要你讲清楚单调性。第二个是：“如果两个指针指向的高度相等，移动哪个？”你需要说明两者的安全性。第三个是：“这道题能和接雨水对比一下吗？”这就需要你理解两类问题的本质差异。
我的建议是，在面试前不仅要能写出代码，还要能用两三句话把双指针的正确性讲清楚。一个推荐的表述是：“当我们固定了较矮的那条边时，无论另一条边怎么向内移动，容器的高度都不可能超过这条较矮边，而宽度又在减小，所以面积不可能增大。因此，这个较矮边作为边界的最大容器已经计算过了，我们可以安全地把它排除掉，继续向内搜索。”这段话既简洁又严谨，面试官听了基本就能确认你理解了这题。
7.4 从这道题延伸出的学习路径建议
如果你正在准备算法面试，或刚开始刷LeetCode，我建议以“盛最多水的容器”为起点，按照以下顺序刷题：
-
- 两数之和 II - 输入有序数组（相向双指针入门）
-
- 盛最多水的容器（本题，双指针优化面积）
-
- 接雨水（双指针/动态规划进阶）
-
- 柱状图中最大的矩形（单调栈，和双指针配合）
-
- 三数之和（排序+双指针组合）
这一组题刷下来，你就基本掌握了相向双指针、动态规划、单调栈三类常用解法，以及它们在不同题目中的适用边界。我自己就是从这套路径走过来的，现在再看新的双指针题，基本都能很快判断出能不能用、怎么用、用的时候要注意什么。
最后还有一个小技巧：本地调试时，把双指针每一步的left、right、height[left]、height[right]、area都打印出来，对比一下暴力法的结果。这个过程能帮你快速建立“指针移动如何影响面积”的直觉，比单纯看题解的效果好得多。这道题看似简单，但真正把双指针理解透后，后续很多中等难度的数组题都会变得顺畅很多。