单调栈习题

最新推荐文章于 2023-05-19 19:50:09 发布
最新推荐文章于 2023-05-19 19:50:09 发布
阅读量410 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41183791/article/details/89431494
版权

例题:

Largest Rectangle in a Histogram

题意:找出柱状图内最大矩形块,求最大面积

解析:

用单调栈处理,找不小于该点的最左端和最右端

ans=max(ans,(r-l+1)*h[i]);

ac:

#include<bits/stdc++.h>
#define ll long long
#define MAXN 100005
using namespace std;
stack<int> sk;
int a[MAXN];
int aa[MAXN];
int bb[MAXN];

int main()
{
    int n,x,y;
    while(scanf("%d",&n)&&n)
    {
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        for(int i=1;i<=n;i++)
        {
            while(sk.size()&&a[sk.top()]>=a[i])
                sk.pop();
            if(sk.empty())
                aa[i]=1;
            else
                aa[i]=sk.top()+1;//找相等的点,即是第一个小于的点+1
            sk.push(i);
        }
        while(!sk.empty())
            sk.pop();
        for(int i=n;i>=1;i--)
        {
            while(sk.size()&&a[sk.top()]>=a[i])
                sk.pop();
            if(sk.empty())
                bb[i]=n;
            else
                bb[i]=sk.top()-1;//同上
            sk.push(i);
        }
        while(!sk.empty())
            sk.pop();
        ll ans=0;//注意int溢出
        for(int i=1;i<=n;i++)
            ans=max(ans,(ll)(bb[i]-aa[i]+1)*a[i]);
        printf("%lld\n",ans);
    }
    return 0;
}

https://ac.nowcoder.com/acm/contest/881/A

题意:

给定2个数组,1<=l<=r<=m,找到最大的m,对于a数组和b数组在区间(1,m)中的任意(l,r)区间内的最小值下标相同

解析:

直接从左往右遍历,找m点往左的第一个比m小的点,如果a数组和b数组相同ans++,否则跳出

这里单调栈虽然仅仅找的是第一个比a[m]小的,但是最小是可以通过若干次传递的,我们是从左往右,所以满足单调传递性

L[a]=0,L[b]=a,L[c]=b,L[d]=c;=>区间(1,d)中最小的值坐标为a.

m前面的都是相等的,所以可以传递

ac:

#include<bits/stdc++.h>
#define ll long long
#define MAXN 100005
using namespace std;
int a[MAXN],b[MAXN];
int l[MAXN];
int L[MAXN];

void solve(int n)
{
    stack<int> sk;
    for(int i=1;i<=n;i++)
    {
        while(sk.size()&&a[sk.top()]>=a[i])
            sk.pop();
        if(sk.empty())
            l[i]=0;
        else
            l[i]=sk.top();
        sk.push(i);
    }
    while(!sk.empty())
        sk.pop();
    for(int i=1;i<=n;i++)
    {
        while(sk.size()&&b[sk.top()]>=b[i])
            sk.pop();
        if(sk.empty())
            L[i]=0;
        else
            L[i]=sk.top();
        sk.push(i);
    }
}

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=1;i<=n;i++)
            scanf("%d",&a[i]);
        for(int i=1;i<=n;i++)
            scanf("%d",&b[i]);
        solve(n);
        int f=0;
        for(int i=1;i<=n;i++)
        {
            if(l[i]!=L[i])
                break;
            f++;
        }
        cout<<f<<endl;
    }
    return 0;
}

1.Max answer(单调栈,rmq)

https://nanti.jisuanke.com/t/38228

题意:

求最大的 区间和*区间最小值.(区间内有负数)

解析:

我们把整数部分和负数部分分开求

整数部分:只能是全为整数的区间,就是求矩形最大面积,经典单调栈题目

负数部分:遍历每一个负数a[i]

将区间扩至最大(扩至和最小),然后sum*a[i],贪心一下

扩区间方法:

求出前缀和,后缀和,然后查询a[i]的左边最小的,减去a[i]~a[n],比较是否大于0,判断是否需要往左边扩

查询最小值用rmq算法

总复杂度是O(nlogn)

ac:

线段树+单调栈:170ms

#include<bits/stdc++.h>
#define ls l,m,rt<<1
#define rs m+1,r,rt<<1|1
#define ll long long
#define MAXN 500005
using namespace std;
 
int a[MAXN],b[MAXN],c[MAXN];
ll sum[MAXN],sum2[MAXN];
int n;
 
struct node
{
    ll mins[MAXN<<2];
    void pushup(int rt)
    {
        mins[rt]=min(mins[rt<<1],mins[rt<<1|1]);
    }
 
    void build(int l,int r,int rt,ll v[])
    {
        if(l==r)
        {
            mins[rt]=v[l];
            return ;
        }
        int m=(l+r)>>1;
        build(ls,v);
        build(rs,v);
        pushup(rt);
    }
 
    ll query(int L,int R,int l,int r,int rt)
    {
        if(L<=l&&r<=R){
            return mins[rt];
        }
        int m=(l+r)>>1;
        ll res=1e18;
        if(L<=m)
            res=min(res,query(L,R,ls));
        if(R>m)
            res=min(res,query(L,R,rs));
        return res;
    }
}AA,BB;
 
ll solve()
{
    stack<int> sk;
    for(int i=1;i<=n;i++)
    {
        while(sk.size()&&a[sk.top()]>=a[i])
            sk.pop();
        if(sk.empty())//左边没有,呢么就是0
            b[i]=0;
        else
            b[i]=sk.top();
        sk.push(i);
    }
    while(sk.size())
        sk.pop();
    for(int i=n;i>=1;i--)
    {
        while(sk.size()&&a[sk.top()]>=a[i])
            sk.pop();
        if(sk.empty())
            c[i]=n;
        else
            c[i]=sk.top()-1;
        sk.push(i);
    }
    ll ans=0;
    for(int i=1;i<=n;i++)
        ans=max(ans,(ll)a[i]*(sum[c[i]]-sum[b[i]]));
    return ans;
}
 
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]),sum[i]=sum[i-1]+a[i];
    for(int i=n;i>=1;i--)
        sum2[i]=sum2[i+1]+a[i];
    ll ans=solve();
    AA.build(1,n,1,sum);
    BB.build(1,n,1,sum2);
    for(int i=1;i<=n;i++)
    {
        if(a[i]>=0)
            continue;
        ll aa=AA.query(i,n,1,n,1)-sum[i];
        ll bb=BB.query(1,i,1,n,1)-sum2[i];
        ans=max(ans,(ll)a[i]*(aa+bb+a[i]));
    }
    printf("%lld\n",ans);
    return 0;
}

rmq+单调栈,rmq常数太大:600ms

#include<bits/stdc++.h>
#define ls l,m,rt<<1
#define rs m+1,r,rt<<1|1
#define ll long long
#define MAXN 500005
using namespace std;
 
int a[MAXN],b[MAXN],c[MAXN];
ll sum[MAXN],sum2[MAXN];
int n;
 
ll solve()
{
    stack<int> sk;
    for(int i=1;i<=n;i++)
    {
        while(sk.size()&&a[sk.top()]>=a[i])
            sk.pop();
        if(sk.empty())//左边没有,呢么就是0
            b[i]=0;
        else
            b[i]=sk.top();
        sk.push(i);
    }
    while(sk.size())
        sk.pop();
    for(int i=n;i>=1;i--)
    {
        while(sk.size()&&a[sk.top()]>=a[i])
            sk.pop();
        if(sk.empty())
            c[i]=n;
        else
            c[i]=sk.top()-1;
        sk.push(i);
    }
    ll ans=0;
    for(int i=1;i<=n;i++)
        ans=max(ans,(ll)a[i]*(sum[c[i]]-sum[b[i]]));
    return ans;
}
 
struct node
{
    ll minn[MAXN][25];
    ll query(int a,int b)
    {
        int k = log2(b-a+1);
        return min(minn[a][k],minn[b-(1<<k)+1][k]);
    }
    void buildrmq(ll n,ll c[])
    {
        int tem = (ll)floor(log2((double)n));
        for(int i=1;i<=n;i++)
            minn[i][0]=c[i];
        for(int j=1;j<=tem;j++)
        {
            for(int i=1;i+(1<<j)-1<=n;i++)
                minn[i][j] = min(minn[i][j-1],minn[i+(1<<(j-1))][j-1]);
        }
    }
}AA,BB;
 
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]),sum[i]=sum[i-1]+a[i];
    for(int i=n;i>=1;i--)
        sum2[i]=sum2[i+1]+a[i];
    ll ans=solve();
    AA.buildrmq(n,sum);
    BB.buildrmq(n,sum2);
    for(int i=1;i<=n;i++)
    {
        if(a[i]>=0)
            continue;
        ll aa=AA.query(i,n)-sum[i];
        ll bb=BB.query(1,i)-sum2[i];
        ans=max(ans,(ll)a[i]*(aa+bb+a[i]));
    }
    printf("%lld\n",ans);
    return 0;
}
/*
6
1 -1 -4 3 -5 -4
*/

2.All-one Matrices

给定1个01矩阵,求该矩阵中的独立矩阵,独立矩阵为不被其他1个矩阵完全包含

解析:

对于每个点(i,j),求出它往上的连续的1,即高为hh[i],求i点往两边扩展,高度不小于hh[i]的最左和最右(用前缀+单调栈处理)

得到以(L[i],R[i])为底,高为hh[i]的全1矩形

判断该底下面是否是否全为1,全为1就可以继续向下扩展,这个底就不算(用前缀处理)

如果这个底算,呢么给它标记vis[L[i]][R[i]]=i,以同一底的矩阵只能存在一个,去重

ac:

#include<bits/stdc++.h>
#define ll long long
#define MAXN 3005
using namespace std;
char mm[MAXN][MAXN];
int hh[MAXN][MAXN];
int n,m;
int stk[MAXN],top;
int L[MAXN],R[MAXN];
int num[MAXN];
int vis[MAXN][MAXN];
ll ans;
 
void solve(int x)
{
    top=0;stk[++top]=0;
    for(int i=1;i<=m;i++)//最左
    {
        while(top>0&&hh[x][stk[top]]>=hh[x][i])
            top--;
        L[i]=stk[top]+1;
        stk[++top]=i;
    }
    top=0,stk[++top]=m+1;
    for(int i=m;i>=1;i--)//最右
    {
        while(top>0&&hh[x][stk[top]]>=hh[x][i])
            top--;
        R[i]=stk[top]-1;
        stk[++top]=i;
    }
    for(int i=1;i<=m;i++)//计算下一层的前缀和
        num[i]=num[i-1]+(mm[x+1][i]-'0');
    for(int i=1;i<=m;i++)
    {
        if(mm[x][i]=='0')
            continue;
        if(vis[L[i]][R[i]]==x)
            continue;
        if(num[R[i]]-num[L[i]-1]==R[i]-L[i]+1)
            continue;
        ans++;
        vis[L[i]][R[i]]=x;
    }
}
 
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        scanf("%s",mm[i]+1);
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=m;j++)
        {
            if(mm[i][j]=='0')
                hh[i][j]=0;
            else
                hh[i][j]=hh[i-1][j]+1;
        }
    }
    ans=0;
    for(int i=1;i<=n;i++)
        solve(i);
    printf("%lld\n",ans);
    return 0;
}

 

 

 

Tao_oc
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【栈】单调栈经典例题
SY奇星的OI博客
05-30 388
现在有一个长度为n的序列，在形成的任意子区间中，查找最小的值和此区间和的乘积的最大值。660例如在区间1-6中，最小值为1，区间和为21，积为21；在区间3-5中，最小值为4，区间和为15，积为60；再由遍历其他区间，得出值60为最大，最后您输出了60。
单调栈类型题合集
weixin_39248750的博客
02-15 992
单调栈分为单调递增栈和单调递减栈。 操作规则：（下面都以单调递增栈为例） 如果新的元素比栈顶元素大，就入栈 如果新的元素较小，那就一直把栈内元素弹出来，直到栈顶比新元素小 Stack<Integer> stack = new Stack<>(); for(int i = 0; i < nums.size(); i++) { while(! stack.isEmpty() && stack.peek() > nums[i]) { st.pop(
Max answer （求区间最小值乘区间和的最大结果，维护左右区间+st求区间最大，最小值）
自渡的博客
04-21 2993
Alice has a magic array. She suggests that the value of a interval is equal to the sum of the values in the interval, multiplied by the smallest value in the interval. Now she is planning to find the...
单调栈 四个例题
weixin_30687811的博客
05-18 139
普通栈就5个操作 #include<stack> 0.stack<类型> 名字; 创建 1.名字.push(元素); 压入栈变为新的栈顶 2.m=名字.top(); 获取栈顶元素 3.名字.pop() ; 弹出栈顶元素 4.length=名字.size() 获取栈内元素长度 ps: 对于 顺序栈和链栈 相对于...
C++之单调栈
qq_45836635的博客
02-20 5603
单调栈的性质 单调栈是一种特殊的栈，特殊之处在于栈内的元素都保持一个单调性。 假设下图是一个栈内元素的排列情况(单调递增的栈)： 此时插入情况有两种： （1）插入元素大于栈顶元素： 因为7 > 6，满足栈内元素单调递增的性质，所以可以直接插入7到栈顶 （2）当插入元素小于栈顶元素的时候，当插入3的时候，需要将栈顶的6，4弹出，在插入，例如： 功能 利用单调栈可以找出从左/右遍历第一个比...
分段函数和单调性练习题.pdf
10-12
分段函数和单调性练习题.pdf
Python 练习题100道
02-28
Python 练习题100道
函数的单调性练习题.pdf
12-23
函数的单调性练习题.pdf
导数的单调性练习题.doc
10-03
导数的单调性练习题.doc
分段函数和单调性练习题.doc
10-03
分段函数和单调性练习题.doc
算法之单调栈常见题目
ChenYiRan123456的博客
05-19 557
什么时候需要使用单调栈？ 通常是一维数组，**要寻找任意一个右边或者左边第一个比自己大或小的元素的位置，此时我们就想到可以使用单调栈了**。 单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素高的元素，优点是整个数组只需要遍历一次。所以时间复杂度是O(n)就可以找到每一个元素的右边第一个比它大的元素位置呢？ 更直白来说，就是用一个**栈来记录我们遍历过的元素**，因为我们遍历数组的时候，我们不知道之前都遍历了哪些元素，以至于遍历一个元素找不到是不是之前遍历过一个更小的，所以我
力扣刷题记录-栈与队列相关题目
qq_41857397的博客
09-22 839
对leetcode内关于单调栈题目汇总
单调栈原理及应用 详解 附各种类型的题目练习
zuzhiang的博客
09-29 1万+
欢迎关注我的个人博客：www.zuzhiang.cn 定义： 单调栈，顾名思义，是栈内元素保持一定单调性（单调递增或单调递减）的栈。这里的单调递增或递减是指的从栈顶到栈底单调递增或递减。既然是栈，就满足后进先出的特点。与之相对应的是单调队列。 实现： 例如实现一个单调递增的栈，比如现在有一组数10，3，7，4，12。从左到右依次入栈，则如果栈为空或入栈元素值小于栈顶元素值...
poj 2796 经典单调栈题目
SCAU_BIN的博客
07-23 949
题目描述：对于n个数，求一个区间，使得该区间所有值相加 乘以 该区间最小值 所得值最大 题解：单调栈的应用。题意可以这样说，求以 a[i]为区间最小值 ，求区间所有数的和乘以 a[i]的最大值是多少。这道题，我wa了一天零一夜，终于ac了。。（怪我菜咯。。） 这个过程只要维护个单调栈就行了，首先用一个数组sum去求出前缀和，用lef[i]，right[i]存储以a[i]为最小值的区间的范围。求
单调栈
热门推荐
hebtu666
09-15 1万+
通过使用栈这个简单的结构，我们可以巧妙地降低一些问题的时间复杂度。 单调栈性质： 1、若是单调递增栈，则从栈顶到栈底的元素是严格递增的。若是单调递减栈，则从栈顶到栈底的元素是严格递减的。 2、越靠近栈顶的元素越后进栈。（显而易见） 本文介绍单调栈用法 通过一道题来说明。 POJ2559 1. 题目大意：链接 给出一个柱形统计图(histogram), 它的每个项目的宽度是1， 高度...
2019南昌邀请赛网络赛 I.Max answer
indiewar's blogs(wust_lzl)
04-21 342
单调栈维护左边和右边第一个大于它的位置 用ST表维护区间前缀和的最大值和最小值 当前点小于0的时候就是后半部分Smin−前半部分Smax后半部分Smin-前半部分Smax后半部分Smin−前半部分Smax 大于0的时候就是后半部分Smax−前半部分Smin后半部分Smax-前半部分Smin后半部分Smax−前半部分Smin #include <bits/stdc++.h> using ...
单调栈例题
qq_43556545的博客
10-28 158
题目描述 给一个数组，返回一个大小相同的数组。返回的数组的第i个位置的值应当是，对于原数组中的第i个元素，至少往右走多少步，才能遇到一个比自己大的元素（如果之后没有比自己大的元素，或者已经是最后一个元素，则在返回数组的对应位置放上-1）。 简单的例子： input: 5, 3, 1, 2, 4 return: -1 3 1 1 -1 解法 单调栈 List<Integer> nextExceed(List<Integer> list) { List&l
Max answer(单调栈，rmq)
weixin_30871905的博客
07-02 132
Max answer 题意：给n个数（n<=5e5），定义一个区间的值为，区间内最小的值乘区间和。求n个数所有区间中的最大值。 思路：为了考虑到所有的情况，我们可以枚举每个数字作为最小值时，它所产生的区间的最大值，那么对于一个数字作为最小值，通过单调栈，可以找到这个数字最左最右的区间，在这个区间内，可以通过前缀和来求每个区间的最大和 当a[i]>0,用前缀和最大值...
poj 2796
Mr.CJ
07-20 1395
Feel Good Time Limit: 3000MS   Memory Limit: 65536K Total Submissions: 7547   Accepted: 2039 Case Time Limit: 1000MS   Special Judge Description Bill is developing a
推荐从哪本书学习单调栈这一算法？
最新发布
05-24
该书是算法竞赛进阶级别的教材，其中第5章节详细介绍了单调栈算法，对算法思想及实现进行了讲解，并给出了多个练习题。 4. 《挑战程序设计竞赛》（第2版）作者：秋叶拓哉 该书也是算法竞赛入门级别的经典教材，其中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值