接雨水两题：LeetCode 42/407

42 接雨水-一维 

动态编程，存储每个位置向左与向右的最大值，实现O(n)的时间复杂度。有一个容易出错的地方：计算向左/右的最大高度时，要把自己本身的高度也计算进去。（但是我感觉不应该包括。。。）

一开始不通过的代码： 

class Solution {
public:
    int trap(vector<int>& height) {
        const int n = height.size();

        if(n < 3) return 0;
        vector<int> maxleft(n, 0), maxright(n, 0);
        
        for(int i = 1; i < n; i++) {
            maxleft[i] = max(height[i-1], maxleft[i-1]);
        }
        for(int i = n-2; i >= 0; i--) {
            maxright[i] = max(height[i+1], maxright[i+1]);
        }
        int ans = 0;
        for(int i = 0; i < n; i++) {
            ans += min(maxleft[i], maxright[i]) - height[i];
        }
        return ans;
    }
};

统计最大高度时将自己位置的高度也计入，代码通过： 

class Solution {
public:
    int trap(vector<int>& height) {
        const int n = height.size();

        if(n < 3) return 0;
        vector<int> maxleft(n, 0), maxright(n, 0);
        
        maxleft[0] = height[0];
        for(int i = 1; i < n; i++) {
            maxleft[i] = max(height[i], maxleft[i-1]);
        }
        maxright[n-1] = height[n-1];
        for(int i = n-2; i >= 0; i--) {
            maxright[i] = max(height[i], maxright[i+1]);
        }
        int ans = 0;
        for(int i = 1; i < n-1; i++) {
            ans += min(maxleft[i], maxright[i]) - height[i];
        }
        return ans;
    }
};

暴力法or动态编程，是按照一根根柱子上最多接多少水来计算的。可以借助单调栈一段一段区间的计算。

        说到栈，我们肯定会想到括号匹配了。我们仔细观察蓝色的部分，可以和括号匹配类比下。每次匹配出一对括号（找到对应的一堵墙），就计算这两堵墙中的水。

我们用栈保存每堵墙。

当遍历墙的高度的时候，如果当前高度小于栈顶的墙高度，说明这里会有积水，我们将墙的高度的下标入栈。

如果当前高度大于栈顶的墙的高度，说明之前的积水到这里停下，我们可以计算下有多少积水了。计算完，就把当前的墙继续入栈，作为新的积水的墙。

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

        stack<int> st;
        st.push(0); //栈必须存储索引
        int i = 1, ans = 0;

        while(i < n) {
            while(!st.empty() && height[st.top()] < height[i]) {
                int top = st.top();
                st.pop();
                if(st.empty()) {
                    break; //栈已经空了，没有另外一堵墙来和当前i位置的墙配对
                }
                ans += (min(height[st.top()], height[i]) - height[top]) * (i - st.top() - 1); //两个st.top()都写错了成top(写程序时不过脑子)
            }
            st.push(i++);
        }
        return ans;
    }
};

双指针法：时间、空间效率都是最高的。 思路也很简单，很好理解。

class Solution {
public:
    int trap(vector<int>& height) {
        const int n = height.size();

        int left = 0, right = n - 1;
        int left_max = 0, right_max = 0;
        int ans = 0;
        while(left < right) {
            if(height[left] < height[right]) {
                left_max = max(left_max, height[left]);
                ans += left_max - height[left++];
            }
            else {
                right_max = max(right_max, height[right]);
                ans += right_max - height[right--];
            }
        }
        return ans;
    } 
};