Leetcode: 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.

For example, 
Given [0,1,0,2,1,0,1,3,2,1,2,1], return 6.

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!

方法1：模拟

array [0,1,0,2,1,0,1,3,2,1,2,1]的矩阵如上图所示，是一个3*12的矩阵，然后从矩阵的第一行开始扫描，遇到两个1就加上这两个1之间的水量，只要扫描一遍矩阵就得到水量了，代码如下，小集合通过，大集合memory不够用。

Judge Small: Accepted!

Judge Large: Memory Limit Exceeded

int trap(int A[], int n) {
        // Note: The Solution object is instantiated only once.
        if(A==NULL || n<1)return 0;
    	int highest = A[0];
		for(int i=1;ihighest)highest=A[i];
		int ** matrix = new int*[highest];
		for(int i=0;i

既然memory不够，就把int矩阵改成bool吧，这样空间就由int的4byte缩小到bool的1 byte，但是还是Memory Limit Exceeded

int trap(int A[], int n) {
        // Note: The Solution object is instantiated only once.
        if(A==NULL || n<1)return 0;
    	int highest = A[0];
		for(int i=1;ihighest)highest=A[i];
		bool ** matrix = new bool*[highest];
		for(int i=0;i

但仔细想想感觉这道题应该是扫一遍就能得到结果的。。。

对某个值A[i]来说，能trapped的最多的water取决于在i之前最高的值leftMostHeight[i]和在i右边的最高的值rightMostHeight[i]（均不包含自身）。

如果min(left,right) > A[i]，那么在i这个位置上能trapped的water就是min(left,right) – A[i]。

有了这个想法就好办了，第一遍从左到右计算数组leftMostHeight，第二遍从右到左计算rightMostHeight。

时间复杂度是O(n)。

int trap(int A[], int n) {
        // Note: The Solution object is instantiated only once.
        if(A==NULL || n<1)return 0;
    	
		int maxheight = 0;
		vector leftMostHeight(n);
		for(int i =0; i A[i] ? maxheight : A[i];
		}

		maxheight = 0;
		vector rightMostHeight(n);
		for(int i =n-1;i>=0;i--)
		{
			rightMostHeight[i] = maxheight;
			maxheight = maxheight > A[i] ? maxheight : A[i];
		}

		int water = 0;
		for(int i =0; i < n; i++)
		{
			int high = min(leftMostHeight[i],rightMostHeight[i])-A[i];
			if(high>0)
				water += high;
		}
		return water;
    }

精简下代码：

class Solution {
public:
    int trap(vector& height) {
        if(height.size() < 2) return 0;
        int sz = height.size();
        vector left(sz, 0);
        vector right(sz, 0);
        for(int i = 1; i < sz; i++){
            left[i] = max(left[i-1], height[i-1]);
            right[sz-i-1] = max(right[sz-i], height[sz-i]);
        }
        int water = 0;
        for(int i = 1; i < sz; i++){
            int minh = min(left[i],right[i]);
            water += minh > height[i] ? minh - height[i] : 0;
        }
        return water;
    }
};