单调不减序列查询第一个大于等于_单调栈

84.Largest Rectangle in Histogram最大矩形

单调递增栈的意义，就是在从左往右遍历序列的时候，对于栈中的每一个元素，它的下面那个元素，就是它在序列中左边往刚好小于它的元素。例如，栈中某元素a[i]，它的栈下面的元素是a[j]，其中j<i。那么，从i开始往左数，第一个比a[i]小的元素就是j。

基于单调栈的这一条性质，我们从左往右遍历数组，维护一个单调递增栈。每到来一个数，如果栈空或者该数比栈顶元素大，那么入栈。

如果新来的a[i]比栈顶元素小，那么a[i]先不入栈。此时，假设栈顶元素为a[j]，栈的下一个元素为a[k]，那么以a[j]为高所画的矩形，他的宽度的就是i-1和k+1的闭区间。就可以算一个面积。然后把a[j]出栈。如此比较下去，直到栈空，或者a[i]>=栈顶元素.

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        if(heights.size() == 0) return 0;
        stack<int> st;
        int i = 0, res = 0;
        heights.push_back(0); // 加入一个0,使得最后哪能清空栈
        while(i < heights.size())
        {
            if(st.empty() || heights[i] > heights[st.top()])  // 单调递增，就入栈
                st.push(i ++);
            else
            {
                int t = st.top(); //t为最高点
                st.pop();
                // 由于是单调栈，当t所指向的bar被弹出以后，该bar左边的刚好小于bar的索引一定是st.top(),
                // 而st.top()+1的bar的高度就已经大于等于该bar了。于是，该bar所对应的高度下，其宽度所跨越的范围，
                // 就是st.top() + 1到i-1这个左闭右闭的范围
                if(st.empty())
                    res = max(res, heights[t]*i);
                else
                    res = max(res, heights[t]*(i - st.top() - 1));
            }
        }
        return res;
    }
};

85.Maximal Rectangle上一题的推广。我们一行一行的遍历，每行的每一点计算一个高度，这个高度就是这一点所在列的1的个数。

class Solution {
public:
    int maximalRectangle(vector<vector<char>>& matrix) {
        if(matrix.empty()) return 0;
        const int m=matrix.size(), n=matrix[0].size();
        int area = 0, i=0;
        vector<int> h(n+1, 0);  // 每一行的高度，最后一位是0
        for(const auto& v:matrix){
            for(i=0; i<n; ++i) h[i] = v[i] == '1' ? h[i]+1 : 0; // 该点是'0'时，高度清0，为'1'时，累加
            i=0;   
            stack<int> st;
            while(i<=n){
                if(st.empty() || h[i]>h[st.top()]) st.push(i++);
                else{
                    int t=st.top(); st.pop();
                    area = max(area, h[t]*(st.empty()?i:(i-st.top()-1)));
                }
            }
        }
        return area;
    }
};

42. Trapping Rain Water这题维护一个单调递减栈，新来的比较矮的时候，直接入栈。否则，一行一行去填充雨水。这题不需要在最后一个添加0，因为最终不需要清空栈。栈里面的单调递减的柱子不能收集雨水

class Solution {
public:
    int trap(vector<int>& h) {
        int N=h.size(), i=0;
        if(N<=2) return 0;
        stack<int> s;
        int res=0;
        while(i < N){
            if(s.empty() || h[i] < h[s.top()])
                s.push(i++);
            else{
                int k = s.top(); s.pop();
                if(s.empty()) continue;
                res +=( min(h[i], h[s.top()]) - h[k] ) * (i-s.top() - 1);
            }
        }
        return res;
    }
};