LeetCode

Trapping Rain Water

2014.2.10 03:25

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!

Solution:

　　The first time I tried to solve this problem, I thought I was supposed to scan the array from left to right, and calculate the amount of water every "pond" can hold. Finding the boundary of every "pond" proved to be difficult, and the code proved to be wrong...(x_x)

　　During the second attempt, I changed my way of thinking. Instead of caring about how much water is held in a pond, it would be easier to calculate how much water is held in one grid, it is min(max_height_left_of_here, max_height_right_of_here) - height_of_here.

　　Why? Because it has to be high at both ends and low in the middle to hold any water, isn't it?

　　If that calculation above yields a negative result, it's simply 0. Because here it is too high, the water flows down and cannot be held.

　　In this manner, we just have to calculate how much water is held at every position h[i] and add them up.

　　Two extra arrays are needed to record the maximum heights at both ends.

　　Therefore, total time complexity is O(n). Space complexity is O(n) as well.

Accepted code:

// 5CE, 2WA, 1AC, "const int &x", constant value has no reference.
class Solution {
public:
    int trap(int A[], int n) {
        if (A == nullptr || n < 3) {
            return 0;
        }
        
        vector<int> vl(n), vr(n);
        int i;
        int max_val;
        int result;
        
        max_val = 0;
        for (i = 0; i <= n - 1; ++i) {
            vl[i] = max_val;
            max_val = mymax(max_val, A[i]);
        }
        max_val = 0;
        for (i = n - 1; i >= 0; --i) {
            vr[i] = max_val;
            max_val = mymax(max_val, A[i]);
        }
        
        result = 0;
        for (i = 0; i < n; ++i) {
            max_val = mymax(0, mymin(vl[i], vr[i]) - A[i]);
            result += max_val;
        }
        vl.clear();
        vr.clear();
        
        return result;
    }
private:
    int mymin(const int x, const int y) {
        return (x < y ? x : y);
    }
    
    int mymax(const int x, const int y) {
        return (x > y ? x : y);
    }
};