Trapping Rain Water(leetcode hard)

这是自己在面试微软过程中遇到的编程题，印象比较深刻是因为当时自己尝试想了很多方法都是不对的。

思想：考虑在每一个位置，它可以存多少水。而这取决于它左边最高的板子，它右边最高的板子，这两者的最小值高于当前位置多少。

下面的代码里，forward和backward分别记录的是包括当前位置的板子的最高值。仔细想了下，是否包括当前位置，都是OK的。

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        if(n==0) return 0;
        int forward[n];
        int backward[n];
        forward[0] = height[0];
        for(int i=1;i<n;i++){
            forward[i] = max(height[i], forward[i-1]);
        }
        backward[n-1] = height[n-1];
        for(int i=n-2;i>=0;i--){
            backward[i] = max(height[i], backward[i+1]);
        }
        int ans = 0;
        for(int i=0;i<n;i++){
            int tmp = min(forward[i],backward[i]);
            if(tmp>height[i])
                ans += tmp-height[i];
        }
        return ans;
    }
};
// https://www.cnblogs.com/AndyJee/p/4821590.html

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        int ans = 0;
        if(n==0) return ans;
        int leftmost = height[0], rightmost = height[n-1];
        int l = 0, r = n-1;
        while(l<=r){
            if(leftmost <= rightmost){  // leftmost是短板
               ans += leftmost-height[l];
               l++;
               if(l<=r)
               leftmost = max(leftmost, height[l]);
            }else{        // rightmost是短板
               ans += rightmost - height[r];
               r--;
               if(l<=r)
               rightmost = max(rightmost, height[r]);
            }
        }
        return ans;
    }
};

单调栈解法：http://www.cnblogs.com/grandyang/p/8887985.html

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size();
        stack<int> mystack;  // 单调递减栈 (非严格)
        int ans = 0;
        for(int i=0;i<n;i++){
            if(mystack.empty()){
                mystack.push(i);
            }else{
                if( height[mystack.top()]>=height[i]){
                    mystack.push(i);
                }else{
                    if( mystack.size()>=2){  // 形成一个坑
                        int middle = mystack.top();
                        mystack.pop();
                        int left = mystack.top();
                        int right = i;
                        ans += (min(height[left],height[right])-height[middle])*(right-left-1);
                        i--;
                    }else{
                        mystack.pop();
                        i--;
                        
                    }
                }
            }
        }
        return ans;
    }
};