单调栈

• 保证栈中元素是单调递增/递减的
• 可以找到数组中某个元素左边离他最近>它的数

柱状图中的最大矩形

theme：给定一个数组代表每个矩形的长度（等宽），问能描成的最大矩形（实心）面积？

solution：枚举以每个小矩形高度作为最大矩形的高度，则对于每一个小矩形，我们找到它向左与向右最大能延伸的长度，即左边与右边<它高度的第一个位置，用单调栈实现。 遍历取最大值即可。

int largestRectangleArea(vector<int>& heights) {
        stack<int>s;
        int n=heights.size();
        vector<int>l(n,1),r(n,1);
        for(int i=0;i<n;++i){
            while(!s.empty()&&heights[s.top()]>=heights[i]){
                s.pop();
            }
            if(!s.empty())
                l[i]=i-s.top();
            else
                l[i]=i+1;
            s.push(i);
        }
        while(!s.empty())
             s.pop();
        for(int i=n-1;i>=0;--i){
            while(!s.empty()&&heights[s.top()]>=heights[i]){
                s.pop();
            }
            if(!s.empty())
                r[i]=s.top()-i;
            else
                r[i]=n-i;
            s.push(i);
        }
        int ans=0;
        for(int i=0;i<n;++i){
            ans=max(ans,(l[i]+r[i]-1)*heights[i]);
        }
        return ans;
    }

最大矩形

theme：给定一个01矩阵，求其中全为1的最大矩形面积。

solution：我们以每一列作为底，计算每一行能向左延伸的距离作为小矩形的高，则问题转换为求 柱状图中的最大矩形。

int maximalRectangle(vector<vector<char>>& matrix) {
        int n=matrix.size();
        if(n==0)
            return 0;
        int m=matrix[0].size();
        int dp[n+2][m+2];
        for(int i=0;i<n;++i){
            dp[i][0]=matrix[i][0]=='1'?1:0;
            for(int j=1;j<m;++j){
                dp[i][j]=matrix[i][j]=='1'?dp[i][j-1]+1:0;
            }
        }
        int ans=0;
        stack<int>s;
        for(int i=0;i<m;++i){
            while(!s.empty())
                s.pop();
            vector<int>l(n,1),r(n,1);
            for(int j=0;j<n;++j){
                while(!s.empty()&&dp[s.top()][i]>=dp[j][i])s.pop();
                if(s.empty())
                    l[j]=j+1;
                else
                    l[j]=j-s.top();
                s.push(j);
            }
            while(!s.empty())
                s.pop();
            for(int j=n-1;j>=0;--j){
                while(!s.empty()&&dp[s.top()][i]>=dp[j][i])s.pop();
                if(s.empty())
                    r[j]=n-j;
                else
                    r[j]=s.top()-j;
                s.push(j);
            }
            for(int j=0;j<n;++j)
                ans=max(ans,(l[j]+r[j]-1)*dp[j][i]);
        }
        return ans;
    }

区间最大值的期望

theme：给定一个数组，求它的非空子区间的最大值的期望。

solution：我们枚举每个元素作为区间右边界，找到该元素a[i]左边第一个 大于 它的元素a[j]，则以(j,i]区间任一位置作为左边界，j为右边界形成区间的最大值为a[j],而以[0.j)区间任一位置作为左边界，j为右边界形成区间的情况与以j为右边界的情况的最大值一样，所以用dp[i]记录下以i为右边界的期望。

（注意，如果通过枚举每个元素为最大值的话，算区间个数时数值相同的元素会重复计算了，而枚举元素作为右边界是以区间为单位找最大值，不会重复）

#include<iostream>
#include<iomanip>
#include<stack>
#include<vector>
using namespace std;
 
struct prs {
    int val;
    int ord;
};
 
double calE (vector<int> v) {
    if(v.empty()) {
        return 0;
    }
     
    stack<prs> s;
    prs ptmp;
    ptmp.val = v[0];
    ptmp.ord = 0;
    s.push(ptmp);
     
    double dp[v.size()];
    dp[0] = v[0];
    int i;
    double res = v[0];
     
    for(i = 1; i < v.size(); i++) {
        while(!s.empty() && v[i] >= s.top().val) {
            s.pop();
        }
        if(s.empty()) {
            dp[i] = (i+1)*v[i];
        }
        else {
            dp[i] = (i - s.top().ord)*v[i] + dp[s.top().ord];
        }
        res = res + dp[i];
         
        ptmp.val = v[i];
        ptmp.ord = i;
        s.push(ptmp);
    }
    return res/double((v.size()+1)*v.size()/2);
}
 
int main() {
    int n;
    cin>>n;
    vector<int> v;
     
    int i, tmp;
    for(i = 0; i < n; i++) {
        cin>>tmp;
        v.push_back(tmp);
    }
     
    cout.setf(ios::fixed);
    cout<<fixed<<setprecision(6)<<calE(v)<<endl;
    return 0;
}