每日一题：接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例：
输入: [0,1,0,2,1,0,1,3,2,1,2,1]
输出: 6

方法一：暴力法

扫描数组中的每个元素，我们找出下雨后水能达到的最高位置。通过同时向左和向右找最高的墙。则当前位置的积水量就等于两边最大高度的较小值减去当前高度的值。
时间复杂度：O(n^2)；
空间复杂度：O(1)；

方法二：动态规划

在方法一中，为了找到最大值每次都要向左和向右扫描一次。因此我们如果可以提前存储这个值，就能节约很多时间。为了找每个数组位置左边的最高的墙，我们需要从左到右扫描一遍数组。为了找到右边最高的墙，我们需要从右到左扫描一遍数组。

int trap(vector<int>& height)
{
	if(height == null)
		return 0;
    int ans = 0;
    int size = height.size();
    vector<int> left_max(size), right_max(size);
    left_max[0] = height[0];
    for (int i = 1; i < size; i++) {
        left_max[i] = max(height[i], left_max[i - 1]);
    }
    right_max[size - 1] = height[size - 1];
    for (int i = size - 2; i >= 0; i--) {
        right_max[i] = max(height[i], right_max[i + 1]);
    }
    for (int i = 1; i < size - 1; i++) {
        ans += min(left_max[i], right_max[i]) - height[i];
    }
    return ans;
}

时间复杂度：O(n)；
空间复杂度：O(n)；（需要额外的数组空间来储存）

方法三：栈

用栈来跟踪可能储水最长的条形块。使用栈可以在一次遍历内完成计算。

在遍历数组时维护一个栈。如果当前的条形块小于或等于栈顶的条形块，将条形块的索引入栈，意思是当前的条形块被栈中的前一个条形块界定。如果发现一个条形块长于栈顶，可以确定栈顶的条形块被当前条形块和栈的前一个条形块界定，因此可以弹出栈顶元素并且对答案进行累加。

class Solution {
public:
    int trap(vector<int>& height) {
        int hLen = height.size(), ans = 0, current = 0;
        stack<int> st;
        while (current < hLen){
            while (!st.empty() && height[current] > height[st.top()]){
                int top = st.top();
                st.pop();
                if (st.empty()) break;
                int distance = current - st.top() - 1;
                int boundedHeight = min(height[current], height[st.top()]) - height[top];
                ans += distance * boundedHeight;
            }
            st.push(current++);
        }
        return ans;
    }
};

时间复杂度：O(n)；
空间复杂度：O(n)；（栈的消耗）

方法四：扫描两遍

可以观察到一个规律，积水的多少是由两边较矮的墙来决定。基于这个思路，可以设计一个算法，先从左到右扫描，确定出由左墙决定的所有积水池高度，再从右到左扫描，确定出由右墙决定的积水池高度。注意，对于左墙右墙登高的积水池，只能计算一次。

class Solution {
public:
    int trap(vector<int>& height) {
        if (height.size() == 0) return 0;

        int rightWall = 0, leftWall = height.size() - 1;
        int hLen = height.size();
        int water = 0;
        for (int i = 1; i < hLen; i++){
            if (height[i] >= height[rightWall]){
                for (int j = rightWall; j < i; j++){
                    water += height[rightWall] - height[j];
                }
                rightWall = i;
            }
        }
        if (rightWall == leftWall) return water;

        for (int i = leftWall - 1; i >= 0; i--){
            if (height[i] > height[leftWall]){
                for (int j = leftWall; j > i; j--){
                    water += height[leftWall] - height[j];
                }
                leftWall = i;
            }
        }

        return water;
    }
};

时间复杂度：O(n)；
空间复杂度：O(1)；

方法五：双指针法

与方法四的思路相同，将方法四优化为双指针法，在一次遍历中完成所有操作。

int trap(vector<int>& height) {
    int left = 0, right = height.size() - 1;
    int ans = 0;
    int leftMax = 0, rightMax = 0;
    while (left < right){
        if (height[left] < height[right]) {
            height[left] >= leftMax ? (leftMax = height[left]) : ans += (leftMax - height[left]);
            ++left;
        }
        else {
            height[right] >= rightMax ? (rightMax = height[right]) : ans += (rightMax - height[right]);
            --right;
        }
    }        
    return ans;
}

时间复杂度：O(n)；
空间复杂度：O(1)；