【盛最多水的容器】【接雨水I】

leetcode_【11】盛最多水的容器

https://leetcode-cn.com/problems/container-with-most-water/

1.题目描述

给定 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

**说明：**你不能倾斜容器，且 n 的值至少为 2。

2. 解题思路

这种方法背后的思路在于，两线段之间形成的区域总是会受到其中较短那条长度的限制。此外，两线段距离越远，得到的面积就越大。

• 我们在由线段长度构成的数组中使用两个指针，一个放在开始，一个置于末尾。 此外，我们会使用变量 res 来持续存储到目前为止所获得的最大面积。
• 在每一步中，我们会找出指针所指向的两条线段形成的区域，更新 res，并将指向较短线段的指针向较长线段那端移动一步。

3.代码

//执行用时 :6 ms, 在所有 Java 提交中击败了71.41%的用户
//内存消耗 :44.9 MB, 在所有 Java 提交中击败了59.00%的用户
import java.util.*;
class Solution {
    public int maxArea(int[] height) {
        int res = 0;
        int left = 0;
        int right = height.length-1;
        while(left<right){
            res = Math.max(res,(right-left)*Math.min(height[left],height[right]));
            //舍弃高度较小的
            if ((height[left] > height[right])) {
                right--;
            } else {
                left++;
            }
            }
        return res;
    }
}

leetcode_【42】接雨水

https://leetcode-cn.com/problems/trapping-rain-water/

1.题目描述

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

2.解题思路

思路1：转化成每个位置留下水量的总和

       i位置上留下的水为[0 , (i-1)]的最大值max1,(i+1,length)位置上的max2的两者较小值-该位置的高度：min(max2-max1) - arr[i]。

思路2：依次结算每个位置的水量，max_left和max_right那边数值小结算哪边。并向中间滑动。

思路3：跟思路2一致，减掉了一个指针

思路4：左边最大值小于右边最大值，左指针右滑，左指针位置上能装的水就是左边最大值减去左指针指的值，若左指针指向的值大于左边大值，就不减，说明不能储水，更新左边最大值，当右边最大值小于左边最大值时，右指针左滑，做法跟前类似，直到左指针小于等于右指针跳出循环。

3.代码

思路1代码：转化成每个位置留下水量的总和

//执行用时 :94 ms, 在所有 Java 提交中击败了9.03%的用户
//内存消耗 :38.6 MB, 在所有 Java 提交中击败了74.56%的用户
public static int  trap(int[] arr) {
        if (arr == null || arr.length < 3) {
                return 0;
        }
        int value = 0;
        for (int i = 1; i < arr.length - 1; i++) {
            int leftMax = 0;
            int rightMax = 0;
            for (int l = 0; l < i; l++) {
                leftMax = Math.max(arr[l], leftMax);
            }
            for (int r = i + 1; r < arr.length; r++) {
                rightMax = Math.max(arr[r], rightMax);
            }
            value += Math.max(0, Math.min(leftMax, rightMax) - arr[i]);
        }
        return value;
        }

思路2代码：

//思路2：依次结算每个位置的水量，max_left和max_right那边数值小结算哪边。并向中间滑动。
//执行用时 :3 ms, 在所有 Java 提交中击败了91.44%的用户
//内存消耗 :37 MB, 在所有 Java 提交中击败了86.35%的用户
    public static int trap(int[] arr) {
        if (arr == null || arr.length < 3) {
            return 0;
        }
        int n = arr.length - 2;
        int[] leftMaxs = new int[n];
        leftMaxs[0] = arr[0];//左指针初始化为第一个数
        //求左边的max
        for (int i = 1; i < n; i++) {
            leftMaxs[i] = Math.max(leftMaxs[i - 1], arr[i]);
        }
        int[] rightMaxs = new int[n];
        rightMaxs[n - 1] = arr[n + 1];//右指针初始化为数组最后一个数
//求右边的max
        for (int i = n - 2; i >= 0; i--) {
            rightMaxs[i] = Math.max(rightMaxs[i + 1], arr[i + 2]);
        }
        int value = 0;
        for (int i = 1; i <= n; i++) {
            value += Math.max(0, Math.min(leftMaxs[i - 1], rightMaxs[i - 1]) - arr[i]);
        }
        return value;
    }

思路3代码：

//执行用时 :4 ms, 在所有 Java 提交中击败了46.69%的用户
//内存消耗 :38.3 MB, 在所有 Java 提交中击败了76.90%的用户
   //思路3：减少一个指针
    public static int trap(int[] arr) {
        if (arr == null || arr.length < 3) {
            return 0;
        }
        int n = arr.length - 2;
        int[] rightMaxs = new int[n];
        rightMaxs[n - 1] = arr[n + 1];
        for (int i = n - 2; i >= 0; i--) {
            rightMaxs[i] = Math.max(rightMaxs[i + 1], arr[i + 2]);
        }
        int leftMax = arr[0];
        int value = 0;
        for (int i = 1; i <= n; i++) {
            value += Math.max(0, Math.min(leftMax, rightMaxs[i - 1]) - arr[i]);
            leftMax = Math.max(leftMax, arr[i]);
        }
        return value;
    }

思路4代码：

//执行用时 :3 ms, 在所有 Java 提交中击败了91.44%的用户
//内存消耗 :37.9 MB, 在所有 Java 提交中击败了80.70%的用户
public static int trap4(int[] arr) {
        if (arr == null || arr.length < 3) {
            return 0;
        }
        int value = 0;
        int leftMax = arr[0];
        int rightMax = arr[arr.length - 1];
        int l = 1;//从第二个查看是否能蓄水
        int r = arr.length - 2;从倒数第二个查看是否能蓄水
        while (l <= r) {
            if (leftMax <= rightMax) {
                value += Math.max(0, leftMax - arr[l]);
                leftMax = Math.max(leftMax, arr[l++]);
            } else {
                value += Math.max(0, rightMax - arr[r]);
                rightMax = Math.max(rightMax, arr[r--]);
            }
        }
        return value;
    }