盛最多水的容器

给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i
的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 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
示例 3：

输入：height = [4,3,2,1,4] 输出：16
示例 4：

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

提示：

n = height.length 2 <= n <= 3 * 104 0 <= height[i] <= 3 * 104

来源：力扣（LeetCode）
链接：点我

class Solution {
    /**
        分析：
        方法一：
        只需要算出，每个高度，最多能容纳多少的水。然后取最值即可
        例如：
        只需要找到最左边，第一个 >= 当前高度的，那这个区间，就是左边我最多能装的水
        再找到最右边，第一个>=当前高度的，那么这个区间，就是右边我最多能装的水
        例如当前高度为5
        从左往右，第一个大于等于5的是：8，下标是1
        从右往左，第一个大于等于5的是：7，下标是8
        所以高度为5，最多能装的水 = (8-1)*5

        例如当前高度是7
        从左往右，第一个大于等于7的是8，下标是1
        从右往左，第一个大于等于7的是：7，下标是8，那就是自己本身
        所以高度为7，最多能装的水 = (8-1)*7

        方法二：
        双指针
        left = 0,right = height.length-1;
        height[left]<height[right]：
        水 = height[left]*(right-left),这就算出来，left高度的，最多能容纳多少的水
        left++;

        height[left]>height[right];
        反着来
        right--;

        height[left]==height[right]:
        left++;
        right--;
        
     */
     //方法二：
    public int maxArea(int[] height) {
        int left= 0;
        int right = height.length-1;
        int res = 0;
        while(left<right){
            if(height[left]<height[right]){
                res = Math.max(res,height[left]*(right-left));
                left++;
            }else if(height[left]>height[right]){
                res = Math.max(res,height[right]*(right-left));
                right--;
            }else{
                res = Math.max(res,height[right]*(right-left));
                left++;
                right--;
            }
        }
        return res;
    }

    //  //方法一：
    // public int maxArea(int[] height) {
    //     int[] leftDP = new int[height.length];
    //     int[] rightDP = new int[height.length];
        
    //     for(int i=0;i<height.length;i++){
    //         //从左往右找，第一个>=当前数的
    //         for(int j=0;j<height.length;j++){
    //             if(height[j]>=height[i]){
    //                 leftDP[i] = j;
    //                 break;
    //             }
    //         }
    //     }
        
    //     for(int i=height.length-1;i>=0;i--){
    //         //从右往左找，第一个>=当前数的
    //         for(int j=height.length-1;j>=0;j--){
    //             if(height[j]>=height[i]){
    //                 rightDP[i] = j;
    //                 break;
    //             }
    //         }
    //     }

    //     int res = Integer.MIN_VALUE;
    //     for(int i=0;i<height.length;i++){
    //         res = Math.max(res,(rightDP[i]-leftDP[i])*height[i]);
    //     }
    //     return res;
    // }
}