LC042-接雨水

42. 接雨水

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

示例 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

方法一暴力

思想

遍历出每一个柱子,所对应左右最大的高度,等于两边最大高度的较小值减去当前高度的值

    public int trap(int[] height) {
        int sum = 0;
        for(int i = 0; i < height.length; i++) {
            // 第一个柱子和最后一个柱子不接雨水
            if (i == 0 || i == height.length - 1) continue;
            int rHeight = height[i]; // 记录右边柱子的最高高度
            int lHeight = height[i]; // 记录左边柱子的最高高度
            for (int r = i + 1; r < height.length; r++) {
                if (height[r] > rHeight) rHeight = height[r];
            }
            for (int l = i - 1; l >= 0; l--) {
                if (height[l] > lHeight) lHeight = height[l];
            }
            int h = Math.min(lHeight, rHeight) - height[i];
            if (h > 0) sum += h;
        }
        return sum;
    }

方法二动态规划

• 找到数组中从下标 最后 到最左端最高的条形块高度 left_max。
• 找到数组中从下标 0 到最右端最高的条形块高度right_max。
• ans += Math.min(left_max[i], right_max[i]) - height[i];

    public int trap(int[] height) {
        int sum = 0;
        if (height.length <= 2)
            return 0;
        int[] max_left = new int[height.length];
        int[] max_right = new int[height.length];
        for (int i = 1; i < height.length - 1; i++) {
            //相对于左边  最大值 进行遍历
            max_left[i] = Math.max(max_left[i - 1], height[i - 1]);
        }
        for (int i = height.length - 2; i >= 0; i--) {
            相对于右边  最大值 进行遍历
            max_right[i] = Math.max(max_right[i + 1], height[i + 1]);
        }
        for (int i = 1; i < height.length - 1; i++) {
            int min = Math.min(max_left[i], max_right[i]);
            if (min > height[i]) {
                sum = sum + (min - height[i]);
            }
        }
        return sum;
    }

复杂度:

时间复杂度：O(n)

​ 存储最大高度数组，需要两次遍历，每次 O(n)
​ 最终使用存储的数据更新ans ，O(n)
空间复杂度：O(n) 额外空间。

栈的应用

使用单调栈

单调栈的应用

单调递减栈

• 当后面的柱子高度比前面的低时，是无法接雨水的 当找到一根比前面高的柱子，就可以计算接到的雨水
  所以使用单调递减栈

对更低的柱子入栈

• 更低的柱子以为这后面如果能找到高柱子，这里就能接到雨水，所以入栈把它保存起来

• 平地相当于高度 0 的柱子，没有什么特别影响

• 当出现高于栈顶的柱子时

• 说明可以对前面的柱子结算了 计算已经到手的雨水，然后出栈前面更低的柱子

计算雨水的时候需要注意的是

• 雨水区域的右边 r 指的自然是当前索引 i
• 底部是栈顶 st.top() ，因为遇到了更高的右边，所以它即将出栈，使用 cur 来记录它，并让它出栈
• 左边 l 就是新的栈顶 st.top()
• 雨水的区域全部确定了，水坑的高度就是左右两边更低的一边减去底部，宽度是在左右中间
• 使用乘法即可计算面积

相关解说视频

public int trap(int[] height) {
    int sum = 0;
    Stack<Integer> stack = new Stack<>();
    int current = 0;
    while (current < height.length) {
        //如果栈部位空的话,并且指向的高度大于栈顶高度就一直循环
        while (!stack.empty() && height[current] > height[stack.peek()]) {
            int h = height[stack.peek()];//取出要出栈的元素
            stack.pop();
            if (stack.empty()) {
                break;
            }
            int dis = current - stack.peek() - 1; //两堵墙之前的距离。
            int min = Math.min(height[stack.peek()], height[current]);
            sum = sum + dis * (min - h);
        }
        stack.push(current); //当前指向的墙入栈
        current++; //指针后移
    }
    return sum;
}

双指针

和方法 2 相比，我们不从左和从右分开计算，我们想办法一次完成遍历。

• left_max：左边的最大值，它是从左往右遍历找到的
  right_max：右边的最大值，它是从右往左遍历找到的
  left：从左往右处理的当前下标
  right：从右往左处理的当前下标
• 定理一：在某个位置i处，它能存的水，取决于它左右两边的最大值中较小的一个。
• 定理二：当我们从左往右处理到left下标时，左边的最大值left_max对它而言是可信的，但right_max对它而言是不可信的。（见下图，由于中间状况未知，对于left下标而言，right_max未必就是它右边最大的值）
• 定理三：当我们从右往左处理到right下标时，右边的最大值right_max对它而言是可信的，但left_max对它而言是不可信的。
• 对于位置left而言，它左边最大值一定是left_max，右边最大值“大于等于”right_max，这时候，如果left_max<right_max成立，那么它就知道自己能存多少水了。无论右边将来会不会出现更大的right_max，都不影响这个结果。 所以当left_max<right_max时，我们就希望去处理left下标，反之，我们希望去处理right下标。

    public int trap(int[] height) {
  //确定左右指针
        int left = 0;
        int right = height.length - 1;
        int ans = 0;
        //确定左右指针
        int leftMax = 0;
        int rightMax = 0;
        while (left < right) {
            if (height[left] < height[right]) {
                if (height[left] >= leftMax) {
                    leftMax = height[left];
                } else {
                    ans += (leftMax - height[left]);
                }
                ++left;

            } else {
                if (height[right] >= rightMax) {
                    rightMax = height[right];
                } else {
                    ans += (rightMax - height[right]);
                }
                --right;

            }
        }
        return ans;
    }

时间复杂度：O(N)。遍历了一遍数组。
空间复杂度：O(1)。使用了有限的 left, right, ans, maxleft, maxright。