单调栈总结

LeetCode上有几道单调栈的类型题，这里拿出来总结一下下。

 

单调栈的引入常常是这样一道题：

 

 

 

LeetCode 84. 柱状图中最大的矩形：

class Solution {
public:
    int largestRectangleArea(vector<int>& h) {
        int n = h.size();
        vector<int> l(n,0);
        vector<int> r(n,0);
        
        stack<int> st;
        for(int i = 0;i<n;++i){
            while(st.size() && h[st.top()] >= h[i]) st.pop();//维护单调递增栈
            l[i] = st.size()? st.top()+1 : 0; //求出来i左边比i低的右边的那个
            st.push(i);
        }
        
        while(st.size())st.pop();
        for(int i = n-1;i>=0;--i){
            while(st.size() && h[st.top()] >= h[i]) st.pop();
            r[i] = st.size()? st.top():n;
            st.push(i);
        }
        
        int res = 0;
        for(int i = 0;i<n;++i){
            res = max(res,h[i]*(r[i]-l[i]));
        }
        return res;
    }
    
};

 

 

LeetCode 85. 最大矩形

 

和上题是一个题，自己求一下高度即可：

class Solution {
public:
    
    int solve(vector<int> &h){
        
        stack<int>st;
        int n = h.size();
        vector<int>l(n,0),r(n,0);
        for(int i = 0;i<n;++i){
            while(st.size() && h[st.top()] >= h[i])st.pop();
            l[i] = st.size()?st.top()+1:0;
            st.push(i);
        }
        while(st.size())st.pop();
        for(int i = n-1;i>=0;--i){
            while(st.size() && h[st.top()] >= h[i])st.pop();
            r[i] = st.size()?st.top():n;
            st.push(i);
        }
        
        int res = -1;
        for(int i = 0;i<n;++i)
            res = max(res,h[i]*(r[i]-l[i]));
        return res;
            
    }
    
    int maximalRectangle(vector<vector<char>>& matrix) {
        int n = matrix.size();
        if(!n)return 0;
        int m = matrix[0].size();
        vector<int>h(m,0);
        int ans = -1;
        for(int i = 0;i<n;++i)
        {
            
            for(int j = 0;j<m;++j)
            {
                h[j] = matrix[i][j] == '1'?h[j]+1:0;
            }
            ans = max(ans,solve( h));
        }
        return ans;
        
        
        
    }
};

 

LeetCode ：221. 最大正方形

 

 

改成求正方形，可以单调栈，也可以动态规划：

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        
        int n = matrix.size();
        if(!n)return 0;
        int m = matrix[0].size();
        
        vector< vector<int> > dp(n+1,(vector<int>(m+1,0)) );
        int ans = 0;
        for(int i = 1;i<=n;++i)
            for(int j = 1;j<=m;++j){
                if(matrix[i-1][j-1] == '1'){
                    dp[i][j] = 1+min(min(dp[i-1][j-1],dp[i-1][j]),dp[i][j-1]);
                    ans = max(ans,dp[i][j]);
                }
            }
        return ans*ans;
        
        
    }
};

 

 

 

POJ - 3250

一排人，每个人只能往右看，且只能看到比他低的，视线会被比他高的遮挡住，求所有人能看到的人数总和。

还是单调栈的基本应用：

思路1:求出每个人最右边比他大的即可,可以用单调递减栈来求。

思路2:求每个人被看了多少次，可以从做到有运用一下单调递减栈，栈的大小就是当前位置被看到的次数。

#include<iostream>
#include<stack>

using namespace std;


int n;
const int maxn = 111111;
int h[maxn];
int main()
{
    cin>>n;
    for(int i = 0;i<n;i++)
        cin>>h[i];
    stack<int>st;
    long long ans = 0;
    for(int i = n-1;i>=0;i--)
    {
        while(st.size()&&h[st.top()]<h[i])
            st.pop();
        ans += (st.empty()?n:st.top())-i-1;
        st.push(i);
    }

    cout<<ans<<endl;
}

#include<iostream>
#include<stack>

using namespace std;


int main()
{
    int n,h;
    cin>>n;
    cin>>h;
    stack<int>st;///存放身高
    st.push(h);
    long long ans = 0;

    for(int i = 1;i<n;i++)
    {
        cin>>h;
        while(st.size() && st.top()<=h)
        {
            st.pop();
        }
        ans+=st.size();
        st.push(h);
    }

    cout<<ans<<endl;
}

 

 

 

 

POJ-2082 : 还是第一道题的改编啦，加上宽度而已，用前缀和记录一下就好啦。

 

#include<iostream>
#include<cstdio>
#include<stack>

using namespace std;

const int maxn = 55555;
int n;
int w[maxn],h[maxn];
int wsum[maxn];
int L[maxn],R[maxn];

int  main()
{
    while(cin>>n&&n>0)
    {
        for(int i = 0;i<n;i++)
        {
            cin>>w[i]>>h[i];
            wsum[i+1] = wsum[i] + w[i];
        }


        stack<int> st;
        for(int i = 0;i<n;i++)///Left
        {
            while(st.size() && h[st.top()]>=h[i])
                st.pop();
            L[i] = st.size()?(st.top()+1):0;
            st.push(i);
        }
        ///Right
        while(st.size())st.pop();
        for(int i = n-1;i>=0;i--)
        {
            while(st.size() && h[st.top()]>=h[i])
                st.pop();
            R[i] = st.size()?st.top():n;
            st.push(i);
        }
        long long ans = 0;
        for(int i = 0;i<n;i++)
        {
            ans = max(ans,(long long)h[i]*(wsum[R[i]]-wsum[L[i]]) );
        }
        cout<<ans<<endl;
    }
}

 

 

 

LeetCode 42. 接雨水

 

这道题假的单调栈,直接前缀处理一下最左边比当前大的，而不是单调栈处理的左边第一个比当前大的：

class Solution {
public:
    int trap(vector<int>& height) {
  		int n = height.size();
        vector<int> left(n),right(n);
  		for(int i = 1;i < n;i++){
  			left[i] = max(left[i-1],height[i-1]);
  		}      
  		for(int i = n-2;i>=0;i--){
  			right[i] = max(right[i+1],height[i+1]);
  		}

  		int ans = 0;
  		for(int i = 1;i<=n-2;i++){
  			int level = min(left[i],right[i]);
  			ans += max(0,level - height[i]);
  		}
  		return ans;


    }
};