给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入：height = [1,1]
输出：1

提示：

• n == height.length
• 2 <= n <= 105
• 0 <= height[i] <= 104

碎碎念：短板效应（对向双指针问题），自己做的时候只想到双指针更新边界，选了同向指针，需要考虑的情况很多，复杂到无法思考清楚哈哈哈

大佬解析

Leecode题解Krahets

题目分析

设两指针 i , j ，指向的水槽板高度分别为 h[i] , h[j] ，此状态下水槽面积为 S(i,j) 。由于可容纳水的高度由两板中的 短板 决定，因此可得如下 面积公式 ：

S(i,j)=min(h[i],h[j])×(j−i)

在每个状态下，无论长板或短板向中间收窄一格，都会导致水槽 底边宽度 −1​ 变短：

若向内 移动短板 ，水槽的短板 min(h[i],h[j]) 可能变大，因此下个水槽的面积 可能增大 。
若向内 移动长板 ，水槽的短板 min(h[i],h[j])​ 不变或变小，因此下个水槽的面积 一定变小 。
因此，初始化双指针分列水槽左右两端，循环每轮将短板向内移动一格，并更新面积最大值，直到两指针相遇时跳出；即可获得最大面积。

算法流程：

初始化： 双指针 i , j 分列水槽左右两端；
循环收窄： 直至双指针相遇时跳出；
更新面积最大值 res ；
选定两板高度中的短板，向中间收窄一格；
返回值： 返回面积最大值 res 即可；
正确性证明：
若暴力枚举，水槽两板围成面积 S(i,j) 的状态总数为 C(n,2) 。

假设状态 S(i,j) 下 h[i]<h[j] ，在向内移动短板至 S(i+1,j) ，则相当于消去了 S(i,j−1),S(i,j−2),...,S(i,i+1) 状态集合。而所有消去状态的面积一定都小于当前面积（即 <S(i,j)），因为这些状态：

短板高度：相比 S(i,j) 相同或更短（即 ≤h[i] ）；
底边宽度：相比 S(i,j) 更短；
因此，每轮向内移动短板，所有消去的状态都 不会导致面积最大值丢失 ，证毕。

 思路解读

我们要求的是宽度w 乘以 两个柱子中最短的柱子h，此时我们若移动比较高的柱子，结果只有两种：1.比最短的柱子h 依然高，此时无论这个柱子再高，得到的结果都是h，因为我们要的是最短的，所以不仅宽度w减少了，高度h还没变，结果肯定变小，这是不符合的. 2.比最短的柱子h 矮了，此时h变得更小了，w也减小，就更不可能了。 所以只有移动短的柱子才有可能比原来的结果大，因为虽然宽度w在减小，但可能h变大，w*h整体才有可能变大。h变小的话可能整体变小，但不影响，因为我们已经记录下了最大值了。所以综上只能移动短的柱子. 

class Solution:
    def maxArea(self, height: List[int]) -> int:
        l = 0  # 初始化左指针，指向数组的第一个元素
        r = len(height) - 1  # 初始化右指针，指向数组的最后一个元素
        s = 0  # 初始化最大面积为0
        
        while l < r:  # 当左指针小于右指针时继续循环
            if height[l] < height[r]:  # 如果左边的高度小于右边的高度
                s = max(s, height[l] * (r - l))  # 计算当前面积并更新最大面积
                l += 1  # 移动左指针向右
            else:  # 如果右边的高度小于或等于左边的高度
                s = max(s, height[r] * (r - l))  # 计算当前面积并更新最大面积
                r -= 1  # 移动右指针向左
        
        return s  # 返回计算出的最大面积

整体代码思路 

1. 初始化指针和变量：

   • 使用双指针法，初始化两个指针 l 和 r，分别指向数组 height 的首尾。
   • 初始化 s 为 0，用于存储计算出的最大面积。

2. 循环计算面积：

   • 在 l 小于 r 的条件下循环，通过计算当前 l 和 r 位置的高度和距离得到当前面积，并更新 s。

3. 调整指针：

   • 比较 height[l] 和 height[r] 的高度，移动较小高度的一侧指针，目的是寻找可能更高的高度，从而可能增加容积。

4. 返回结果：

   • 返回计算出的最大面积 s。

这种方法利用双指针法，通过逐步缩小指针间的距离，计算出每一步的面积，并更新最大面积 s。移动高度较小的一侧指针，是为了尝试找到更高的边界，从而可能增加容积。这个方法的时间复杂度为 O(n)。

 双指针+剪枝优化（Leecode题解 OAA基础上一点点优化）

class Solution:
    def maxArea(self, height: List[int]) -> int:
        i, j = 0, len(height) - 1  # 初始化两个指针，分别指向数组的首尾
        max_value = 0  # 初始化最大面积为0
        max_height = max(height)  # 计算数组中的最大高度
        
        while i < j:  # 当左指针小于右指针时继续循环
            # 计算当前面积并更新最大面积
            max_value = max(max_value, min(height[i], height[j]) * (j - i))
            # 如果当前的最大面积除以指针距离已经大于等于最大高度，提前退出
            if max_value / (j - i) >= max_height:
                break
            # 移动高度较小的指针
            if height[i] < height[j]:
                i += 1
            else:
                j -= 1
        
        return max_value  # 返回计算出的最大面积

整体代码思路

1. 初始化指针和变量：

   • 使用双指针法，初始化两个指针 i 和 j，分别指向数组 height 的首尾。
   • 初始化 max_value 为 0，用于存储计算出的最大面积。
   • 计算并存储数组中的最大高度 max_height。

2. 循环计算面积：

   • 在 i 小于 j 的条件下循环，通过计算当前 i 和 j 位置的高度和距离得到当前面积，并更新 max_value。

3. 提前退出优化：

   • 每次计算出当前面积后，检查 max_value / (j - i) 是否大于等于 max_height。如果满足条件，意味着无论如何调整指针，后续的最大面积都不会超过当前的 max_value，可以提前退出循环以节省计算时间。

4. 调整指针：

   • 移动高度较小的指针，目的是寻找可能更高的高度，从而可能增加容积。

5. 返回结果：

   • 返回计算出的最大面积 max_value。

这种方法结合了双指针法和提前退出策略，提高了算法的效率，特别是在某些情况下可以避免不必要的计算。