[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!

方法一：

时间复杂度 O(n)，空间复杂度 O(n)

对于每个柱子，找到其左右两边最高的柱子，该柱子能容纳的面积就是 min(leftMostHeight,rightMostHeight) - height。所以，

1. 从左往右扫描一遍，对于每个柱子，求取左边最大值；

2. 从右往左扫描一遍，对于每个柱子，求最大右值；

3. 再扫描一遍，把每个柱子的面积并累加。

code：

class Solution {
    public: 
        int trap(int A[], int n) 
        {
            vector<int> left;
            vector<int> right;
            left.resize(n);
            right.resize(n);

            //printArray(A, n);

            left[0] == 0;
            right[n-1] == 0;
            
            // get the left's max 
            for(int i = 1; i< n;i++)
            {
                left[i] = max(left[i-1], A[i-1]);
            }
            //printVector(left);

            // get the right's max 
            for(int i = n-2; i>=0;i--)
            {
                right[i] = max(right[i+1], A[i+1]);
            }
            //printVector(right);

            // clac the trap water
            int sum =0;
            int height = 0;
            for(int i = 0; i< n;i++)
            {
                height = min(left[i], right[i]);
                if(height > A[i])
                    sum += height - A[i];
            }
            return sum;
        }
};

方法二：

时间复杂度 O(n)，空间复杂度 O(1)

1. 扫描一遍，找到最高的柱子，这个柱子将数组分为两半；

2. 处理左边一半；

3. 处理右边一半。

class Solution {
    public:
        int trap(int A[], int n) {
            int max = 0;  
            for(int i = 0; i < n; i++)
                if (A[i] > A[max]) max = i;
            int water = 0;
            int left_max_height = 0;
            // calc the left_max_height, at the same time update water
            for (int i = 0; i < max; i++)
                if (A[i] > left_max_height) 
                    left_max_height = A[i];
                else 
                    water += left_max_height - A[i];
            int right_max_height = 0;
            // calc the right_max_height, at the same time update water
            for (int i = n - 1; i > max; i--)
                if (A[i] > right_max_height) 
                    right_max_height = A[i];
                else 
                    water +=  right_max_height - A[i];
            return water;
        }   
};

方法3：

// LeetCode, Trapping Rain Water

// 用一个栈辅助，小于栈顶的元素压入，大于等于栈顶就把栈里所有小于或

// 等于当前值的元素全部出栈处理掉，计算面积，最后把当前元素入栈

// 时间复杂度 O(n)，空间复杂度 O(n)

可以用std::pair 代替 struct Node结构

 

struct Node
{
    int val;
    int index;
    Node(){}
    Node(int v, int idx):val(v), index(idx){}
};

class Solution {
    public:
        int trap(int A[], int n) {
            stack<Node> s;
            int sum = 0;
            for(int i = 0; i < n; i++)
            {
                int height = 0;
        // 将栈里比当前元素矮或等高的元素全部处理掉
                while(!s.empty())
                {
                    Node node = s.top();
            // 碰到了比当前元素高的，先计算面积，如{4,3，2}，再跳出while循环, 将当前元素压栈
                    if (A[i] < node.val ) // A[] = {4, 2,3}, calc sum
                    {
                        int width = i - node.index - 1;
                        sum += A[i] * width - height * width;
                        break;
                    }
                    else
                    {
            // node.val, height, a[i] 三者夹成的凹陷
                        int width = i - node.index - 1;
                        sum += node.val * width - height * width;
                        height = node.val;// update height
                // 弹出栈顶，因为该元素处理完了，不再需要了
                        s.pop();
                    }
                }
        // 所有元素都要入栈
                s.push(Node(A[i], i));
            }

            return sum;
        }
};