LintCode 363: Trapping Rain Water (蓄水池经典题!!!)

363. 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.

Trapping Rain Water

Example
Given [0,1,0,2,1,0,1,3,2,1,2,1], return 6.

Challenge
O(n) time and O(1) memory

O(n) time and O(n) memory is also acceptable.

注意这道题不要跟直方图求最大矩形混淆。那道题是用单调栈实现。
注意某个矩形块上方的水就是该矩形块左右侧最高的矩形块的高度的较低值与其本身高度的差。
单调栈是找左右两边第一个比该元素大(或小)的元素。

解法1：
先求出最高的矩形长度maxHeight和maxIndex，然后从左右两边分头算。算出最高高度后，maxIndex左边的矩形块的右侧最高长度就是maxHeight, 只需要找出其左侧最高长度即可。
maxIndex右边的矩形块的左侧最高长度就是maxHeight，只需要找出其右侧最高长度即可。
代码如下：

class Solution {
public:
    /**
     * @param heights: a list of integers
     * @return: a integer
     */
    int trapRainWater(vector<int> &heights) {
        int len = heights.size();
        if (len == 0) return 0;
        
        int maxHeight = 0;
        int maxIndex = 0;
        
        for (int i = 0; i < len; ++i) {
            if (maxHeight < heights[i]) {
                maxHeight = heights[i];
                maxIndex = i;
            }
        }
        
        int sum = 0;
        maxHeight = 0;
        for (int i = 0; i < maxIndex; ++i) {
            if (maxHeight > heights[i]) {
                sum += maxHeight - heights[i];
            } else {
                maxHeight = heights[i];
            }
        }
        
        maxHeight = 0;
        for (int i = len - 1; i > maxIndex; --i) {
            if (maxHeight > heights[i]) {
                sum += maxHeight - heights[i];
            } else {
                maxHeight = heights[i];
            }
        }
        
        return sum;
    }
};

解法2：单调栈。
感觉这题也能用单调(递减?)栈来做。先求出最高的矩形，然后两边分别用单调栈?
注意，不可以。单调栈是求左右两边第一个大于或小于该数的位置。而这里是要求这个数左右两边的最大值！

解法3：双指针。类似解法1。
注意某个矩形块上方的水就是该矩形块左右侧最高的矩形块的高度的较低值与其本身高度的差。所以用双指针，一左一右夹逼，每次更新lMax和rMax，而heights[i]上方的水就是lMax和rMax的最小值与heights[p1]或heights[p2]的差。
代码如下：

class Solution {
public:
    /**
     * @param heights: a vector of integers
     * @return: a integer
     */
    int trapRainWater(vector<int> &heights) {
        int len = heights.size();
        if (len == 0) return 0;
        
        int lMax = 0, rMax = 0;
        int p1 = 0, p2 = len - 1;
        int sum = 0;
        
        while(p1 < p2) {
            if (lMax < heights[p1]) {
                lMax = heights[p1];
            }
            if (rMax < heights[p2]) {
                rMax = heights[p2];
            }
            
            if (lMax  < rMax) {
                sum += lMax - heights[p1];
                p1++;
            } else {
                sum += rMax - heights[p2];
                p2--;
            }
        }
        return sum;
        
    }
};

二刷:

class Solution {
public:
    /**
     * @param heights: a list of integers
     * @return: a integer
     */
    int trapRainWater(vector<int> &heights) {
        int res = 0;
        int len = heights.size();
        int left = 0, right = len - 1;
        int leftMax = 0, rightMax = 0;
        while (left < right) {
            leftMax = max(heights[left], leftMax);
            rightMax = max(heights[right], rightMax);
            if (leftMax < rightMax) {
                res += leftMax - heights[left];
                left++;
            } else {
                res += rightMax - heights[right];
                right--;
            }
        }
        return res;
    }
};

注意：这里不是要求某个数左右两边的最大值吗？当(leftMax < rightMax)时，为什么rightMax还没有到left，就可以用

if (leftMax < rightMax) {
    res += leftMax - heights[left];
    left++;
}

呢？注意这里是求min(leftMax, rightMax)，如果leftmax<rightMax，那么即使从left到right还有很长距离，并且某个数还>rightMax的话，那也没关系，因为leftMax还是会小于那个数。这时候min(leftMax,rightMax)就可以定下来是等于leftMax了。反之当leftMax>=rightMax时，也是一样。

代码同步在
https://github.com/luqian2017/Algorithm