数据结构与算法---盛最多水的容器、接雨水

盛最多水的容器

11. 盛最多水的容器
给你 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

---

思路1：暴力法

两根for循环
求出每两根柱子的盛水量，找出最大值

class Solution {
    public int maxArea(int[] height) {
        if(height == null || height.length < 2) return 0;
        int max = 0;
        for(int i = 0; i < height.length - 1; i++){
            for(int j = i + 1; j < height.length; j++){
                max = Math.max(max, (j - i) * Math.min(height[i], height[j]));
            }
        }
        return max;
    }
}

---

思路2：双指针

左边一个指针，右边一个指针，算出一个值后，让指针指向值小的柱子往中间走

class Solution {
    public int maxArea(int[] height) {
        if(height == null || height.length < 2) return 0;
        int max = 0;
        int left = 0;
        int right = height.length - 1;

        while(left < right){
           max = Math.max(max, (right - left) * Math.min(height[left], height[right]));
           if(height[left] > height[right]){
               right--;
           }else{
               left++;
           }
        }
        return max;
    }
}

假如现在要将left++，height[left + 1] < height[left]，也就是后面的柱子还没之前的柱子长，则继续left++
同理，右边的柱子一样

class Solution {
    public int maxArea(int[] height) {
        if(height == null || height.length < 2) return 0;
        int max = 0;
        int left = 0;
        int right = height.length - 1;

        while(left < right){
           max = Math.max(max, (right - left) * Math.min(height[left], height[right]));
           if(height[left] > height[right]){
               while((left < right) && (height[right - 1] < height[right])){
                   right--;
               }
               right--;
           }else{
               while((left < right) && (height[left] > height[left + 1])){
                   left++;
               }
               left++;
           }
        }
        return max;
    }
}

MJ的写法：

class Solution {
    public int maxArea(int[] height) {
        if(height == null || height.length < 2) return 0;
        int max = 0;
        int left = 0;
        int right = height.length - 1;

        while(left < right){
           max = Math.max(max, (right - left) * Math.min(height[left], height[right]));
           if(height[left] > height[right]){
               int minH = height[right];
               while((left < right) && (height[right] <= minH)){
                   right--;
               }
           }else{
               int minH = height[left];
               while((left < right) && (height[left] <= minH)){
                   left++;
               }
           }
        }
        return max;
    }
}

思路是一样的

---

接雨水

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

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

示例 2：
输入：height = [4,2,0,3,2,5]
输出：9

提示：

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

---

思路

首先，第一根柱子和最后一根柱子是不能存水的，排除

然后，其余的柱子的存水量，比如A的存水量，取决于柱子A左边的所以柱子的最大值leftMax，和柱子A右边的所以柱子的最大值rightMax，两个值中比较小的那个，再减去自身的高度，就是存水量

class Solution {
    public int trap(int[] height) {
        //边界值
        if(height == null || height.length == 0) return 0;

        int lastId = height.length - 2;
        int[] leftMaxes = new int[height.length];
        int[] rightMaxes = new int[height.length];

        leftMaxes[0] = 0;
        rightMaxes[height.length - 1] = 0;
        int leftMax = 0;
        for(int i = 1; i < leftMaxes.length; i++){
            leftMax = Math.max(leftMax, height[i - 1]);
            leftMaxes[i] = leftMax;
        }

        int rightMax = 0;
        for(int i = height.length - 2; i >= 0; i--){
            rightMax = Math.max(rightMax, height[i + 1]);
            rightMaxes[i] = rightMax;
        }


        int sum = 0;
        for(int i = 1; i <= lastId; i++){
            int min = Math.min(leftMaxes[i], rightMaxes[i]);
            if(min > height[i]){
                sum += (min - height[i]);
            }
        }
        return sum;
    }
}

从8月份开始，到11月26号，数据结构三季共130+个小时终于看完了
学到了很多，感谢MJ老师
算是算法入了门，以后的路还很长，希望可以继续学习，继续努力
可以刷一遍《剑指offer》
再来一下LeetCode前200道热门题
加油！