[LeetCode] 42. Trapping Rain Water

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.

The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for contributing this image!

Example:

Input: [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6

收集雨水。题意是给一个整数数组，数组包含的是一堆高度不同的bar，表示的是一个高度图（elevation map）。求此高度图能存水多少。这个题目有多种思路，此处我给出两种解法，一种双指针，一种单调栈。

首先是双指针解法（two pointer）。思路是对于任意位置i，在i上的积水，是由其左右两边较矮的bar（可以想象为挡板）的高度和i位置的高度的差值决定的。即volume[i] = Math.min(Math.min(left[i], right[i]) - A[i]) * 1。这里的1是宽度。所以写代码的时候需要从左往右和从右往左各扫一遍，这样可以得出在每个位置上因着左边的bar和右边的bar的高度，能存水多少。代码如下，

时间O(n)

空间O(1)

Java实现

class Solution {
    public int trap(int[] height) {
        int left = 0;
        int right = height.length - 1;
        int res = 0;
        int leftMax = 0;
        int rightMax = 0;
        while (left < right) {
            if (height[left] < height[right]) {
                leftMax = Math.max(height[left], leftMax);
                res += leftMax - height[left];
                left++;
            } else {
                rightMax = Math.max(height[right], rightMax);
                res += rightMax - height[right];
                right--;
            }
        }
        return res;
    }
}

JavaScript实现

/**
 * @param {number[]} height
 * @return {number}
 */
var trap = function(height) {
    let left = 0;
    let right = height.length - 1;
    let res = 0;
    let leftMax = 0;
    let rightMax = 0;
    while (left < right) {
        if (height[left] < height[right]) {
            leftMax = Math.max(leftMax, height[left]);
            res += leftMax - height[left];
            left++;
        } else {
            rightMax = Math.max(rightMax, height[right]);
            res += rightMax - height[right];
            right--;
        }
    }
    return res;
};

再来是单调栈的解法。单调栈的思想可以参见84题。动图可以参考这个帖子。对于本题来说，我们寻求的是一个单调递减栈。栈内存的是数组的下标。当遇到一个元素比栈顶元素大的时候，就开始往外pop元素。这样被pop的坐标对应的水量其实是最低点，左挡板是最低点左边的一个index，右挡板是当前这个比栈顶元素大的高度。其他计算水量的步骤跟双指针没有区别。

Java实现

class Solution {
    public int trap(int[] height) {
        // corner case
        if (height == null || height.length == 0) {
            return 0;
        }

        // normal case
        Stack<Integer> stack = new Stack<>();
        int res = 0;
        for (int i = 0; i < height.length; i++) {
            while (!stack.isEmpty() && height[stack.peek()] < height[i]) {
                int index = stack.pop();
                // 如果栈顶元素一直相等，那么全都pop出去，只留第一个
                while (!stack.isEmpty() && height[stack.peek()] == height[index]) {
                    stack.pop();
                }
                if (!stack.isEmpty()) {
                    int start = stack.peek();
                    res += (Math.min(height[start], height[i]) - height[index]) * (i - start - 1);
                }
            }
            stack.add(i);
        }
        return res;
    }
}

JavaScript实现

/**
 * @param {number[]} height
 * @return {number}
 */
var trap = function (height) {
    // corner case
    if (height === null || height.length === 0) {
        return 0;
    }

    // normal case
    let stack = [];
    let res = 0;
    for (let i = 0; i < height.length; i++) {
        while (stack.length && height[stack[stack.length - 1]] < height[i]) {
            let index = stack.pop();
            while (
                stack.length &&
                height[stack[stack.length - 1]] == height[index]
            ) {
                stack.pop();
            }
            if (stack.length) {
                let start = stack[stack.length - 1];
                res +=
                    (Math.min(height[start], height[i]) - height[index]) *
                    (i - start - 1);
            }
        }
        stack.push(i);
    }
    return res;
};

LeetCode 题目总结