单调栈+RMQ

最新推荐文章于 2022-10-25 11:42:30 发布
最新推荐文章于 2022-10-25 11:42:30 发布
阅读量748 收藏
点赞数 1
分类专栏： ACM专题 文章标签： 单调栈+RMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43333395/article/details/89448544
版权

单调栈+RMQ

贴上单调栈介绍：
https://blog.csdn.net/qq_43333395/article/details/89426429
贴上RMQ介绍：
https://blog.csdn.net/qq_43333395/article/details/89442824

例题一 区间的价值

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5696

题意

给出一个长度为n（1 <= n <= 100000）的序列，区间权值为区间最大值乘以区间最小值，输出长度为1到n的区间的最大权值。

题解

先利用单调栈算出以a[i]为最小值的最大区间延伸，设该区间宽度为L，则更新ans[L]（这里用到st表查询该区间最大值），最后从宽度较大的区间刷新宽度较小的区间的长度，即为答案。

为什么是对的，可以证明一下，从结果考虑，宽度为k的区间的最优值一定可以被这种方式取到。
ac代码：

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
typedef long long lint;
#define maxn (100010)
#define left lleft
#define right rright
#define log2 Log2
int a[maxn], left[maxn], right[maxn];
lint ans[maxn];
int log2[maxn], st[maxn][32];
void st_prepare(int arr[], int n)
{
    log2[1] = 0;
    for(int i = 2; i <= n; i++)
    {
        log2[i] = log2[i-1];
        if((1 << log2[i] + 1) == i)
            log2[i]++;
    }
    for(int i = n-1; i >= 0; i--)
    {
        st[i][0] = arr[i];
        for(int j = 1; i + (1 << j) - 1 < n; j++)
        {
            st[i][j] = max(st[i][j-1], st[i+(1<<j-1)][j-1]);
        }
    }
}
int st_query(int l, int r)
{
    int len = log2[r - l + 1];
    return max(st[l][len], st[r - (1 << len) + 1][len]);
}
#define stack Stack
pair<int, int> stack[maxn];
int top;
void push_stack(int id, int w, int val[], int mx)
{
    while(top > 0)
    {
        if(stack[top].first < w)
            break;
        top--;
    }
    if(!top) val[id] = mx;
    else val[id] = stack[top].second;
    stack[++top] = make_pair(w, id);
}
int main()
{
    int n;
    while(cin >> n)
    {
        for(int i = 1; i <= n; i++)
            scanf("%d", &a[i]);
        st_prepare(a + 1, n);
        top = 0;
        for(int i = 1; i <= n; i++)
        {
            push_stack(i, a[i], left, 0);
        }
        top = 0;
        for(int i = n; i >= 1; i--)
        {
            push_stack(i, a[i], right, n + 1);
        }
        for(int i = 0; i <= n; i++) ans[i] = -1;
        for(int i = 1, l, r, k; i <= n; i++)
        {
            l = left[i];
            r = right[i] - 2;
            k = st_query(l, r);
            ans[r - l + 1] = max(ans[r - l + 1], (lint)k * a[i]);
        }
        for(int i = n - 1; i >= 1; i--)
            ans[i] = max(ans[i], ans[i + 1]);
        for(int i = 1; i <= n; i++)
            printf("%I64d\n", ans[i]);
    }

    return 0;
}

自己代码：（ac了，具体模板参照上面两个链接）

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
#include <iostream>
#include <stack>
using namespace std;
typedef long long ll;
const int N=100010;
ll arr[N];
ll dp[N][35],n;
ll L[N],R[N];
ll ans[N];
//rmq的建立
void rmq_init(){

    for(int i=1;i<=n;i++)
        dp[i][0]=arr[i];
    for(int i=1;(1<<i)<=n;i++)
        for(int j=1;j+(1<<i)-1<=n;j++)
        dp[j][i]=max(dp[j][i-1],dp[j+(1<<(i-1))][i-1]);

}

//rmq的查询
ll rmq_qui(int l,int r){
    int k=(int)log2(double(r-l+1));//不要写成log(double)(r-l+1)/log(2.0)；会wa
    return max(dp[l][k],dp[r-(1<<k)+1][k]);
}

void single_stack_l(){
    stack<int >S;
    while(S.size()) S.pop();
    S.push(0);
    for(int i=1;i<=n;i++){
        while(S.size()&&arr[S.top()]>=arr[i]) S.pop();

        if(S.empty()) L[i]=0;
        else L[i]=S.top();

        S.push(i);
    }
}

void single_stack_r(){
    stack<int>S;
    while(S.size()) S.pop();
    S.push(n+1);
    for(int i=n;i>=1;i--){
        while(S.size()&&arr[S.top()]>=arr[i]) S.pop();

        if(S.empty()) R[i]=n+1;
        else R[i]=S.top();

        S.push(i);
    }
}


int main(){
    int a,b;
    while(~scanf("%lld",&n)&&n){
    memset(dp,0,sizeof(dp));
    memset(arr,0,sizeof(arr));
    memset(L,0,sizeof(L));
    memset(R,0,sizeof(R));
    memset(ans,0,sizeof(ans));
    for(int i=1;i<=n;i++)
        scanf("%lld",&arr[i]);
        arr[0]=arr[n+1]=INT_MIN;
    rmq_init();
    int q,p;

    single_stack_l();
    single_stack_r();

    for(int i=0;i<=n;i++) ans[i]=-1;
    for(int i=1,l,r,k;i<=n;i++){
        l=L[i];
        r=R[i]-2;
        k=rmq_qui(l+1,r+1);
        ans[r-l+1]=max(ans[r-l+1],(ll)k*arr[i]);
    }
    for(int i=n-1;i>=1;i--)
            ans[i]=max(ans[i],ans[i+1]);
    for(int i=1;i<=n;i++)
            printf("%lld\n",ans[i]);
    }
            return 0;
}

例题二 Max answer

链接：https://nanti.jisuanke.com/t/38228

题目大意：

选一段区间，用最小值乘与区间的所有值，问能求得的最大值是多少。
（如果最小值只能是正数，则可以用单调栈，但是含有负数，则用单调栈+RMQ）

#include <bits/stdc++.h>

using namespace std;
#define LL long long
#define fi first
#define se second
#define pb push_back
#define ls rt<<1, l, m
#define rs rt<<1|1, m+1, r
const int N = 5e5 + 5;
int a[N], pre[N], suf[N];
LL sum[N], mx[N<<2], mn[N<<2];
stack<int> st;
int n;
void push_up(int rt) {
    mn[rt] = min(mn[rt<<1], mn[rt<<1|1]);
    mx[rt] = max(mx[rt<<1], mx[rt<<1|1]);
}
void build(int rt, int l, int r) {
    if(l == r) {
        mx[rt] = mn[rt] = sum[l];
        return ;
    }
    int m = l+r >> 1;
    build(ls);
    build(rs);
    push_up(rt);
}
LL querymx(int L, int R, int rt, int l, int r) {
    if(L <= l && r <= R) return mx[rt];
    int m = l+r >> 1;
    LL ans = LONG_MIN;
    if(L <= m) ans = max(ans, querymx(L, R, ls));
    if(R > m) ans = max(ans, querymx(L, R, rs));
    return ans;
}
LL querymn(int L, int R, int rt, int l, int r) {
    if(L <= l && r <= R) return mn[rt];
    int m = l+r >> 1;
    LL ans = LONG_MAX;
    if(L <= m) ans = min(ans, querymn(L, R, ls));
    if(R > m) ans = min(ans, querymn(L, R, rs));
    return ans;
}
int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
    for (int i = 1; i <= n; ++i) sum[i] = sum[i-1] + a[i];
    build(1, 0, n);
    a[0] = a[n+1] = INT_MIN;
    st.push(0);
    for (int i = 1; i <= n; ++i) {
        while(!st.empty() && a[st.top()] >= a[i]) st.pop();
        pre[i] = st.top();
        st.push(i);
    }
    while(!st.empty()) st.pop();
    st.push(n+1);
    for (int i = n; i >= 1; --i) {
        while(!st.empty() && a[st.top()] >= a[i]) st.pop();
        suf[i] = st.top();
        st.push(i);
    }
    LL ans = 0;
    for (int i = 1; i <= n; ++i) {
        int l = pre[i], r = i-1;
        int ll = i, rr = suf[i]-1;
        if(a[i] < 0) {
            ans = max(ans, a[i]*(querymn(ll, rr, 1, 0, n)-querymx(l, r, 1, 0, n)));
        }
        else if(a[i] > 0) {
            ans = max(ans, a[i]*(querymx(ll, rr, 1, 0, n)-querymn(l, r, 1, 0, n)));
        }
    }
    printf("%lld\n", ans);
    return 0;
}

自己的代码：（wa了一个点呜呜呜）

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
#include <iostream>
#include <stack>
using namespace std;
typedef long long ll;
const int N=500005;
ll arr[N];
ll dp[N][31],n,pd[N][31];
int L[N],R[N];
ll sum[N];
//rmq的建立
void rmq_init(){
    for(int i=1;i<=n;i++)
        dp[i][0]=sum[i];
    for(int i=1;(1<<i)<=n;i++)
        for(int j=1;j+(1<<i)-1<=n;j++)
        dp[j][i]=max(dp[j][i-1],dp[j+(1<<(i-1))][i-1]);
    for(int i=1;i<=n;i++)
        pd[i][0]=sum[i];
    for(int i=1;(1<<i)<=n;i++)
        for(int j=1;j+(1<<i)-1<=n;j++)
        pd[j][i]=min(pd[j][i-1],pd[j+(1<<(i-1))][i-1]);
}

//rmq的查询
ll rmq_qui_max(int l,int r){
    int k=(int)log2(double(r-l+1));
    return max(dp[l][k],dp[r-(1<<k)+1][k]);
}
ll rmq_qui_min(int l,int r){
    int k=(int)log2(double(r-l+1));
    return min(pd[l][k],pd[r-(1<<k)+1][k]);
}

void single_stack_l(){
    stack<int>S;
    while(S.size()) S.pop();
    S.push(0);
    for(int i=1;i<=n;i++){
        while(S.size()&&arr[S.top()]>=arr[i]) S.pop();
        if(S.empty()) L[i]=0;
        else
        L[i]=S.top();

        S.push(i);
    }
}

void single_stack_r(){
    stack<int>S;
    while(S.size()) S.pop();
    S.push(n+1);
    for(int i=n;i>=1;i--){
        while(S.size()&&arr[S.top()]>=arr[i]) S.pop();
        if(S.empty()) R[i]=n+1;
        else
         R[i]=S.top();

        S.push(i);
    }
}


int main(){
    scanf("%lld",&n);
    arr[0]=arr[n+1]=-1e9;
    for(int i=1;i<=n;i++)
        scanf("%lld",&arr[i]);
    sum[0]=0;
    for(int i=1;i<=n;i++)sum[i]=sum[i-1]+arr[i];
    rmq_init();
    single_stack_l();
    single_stack_r();

    ll ans=-1e18;
    for (int i=1;i<=n;i++) {
        int l=L[i],r=i-1;
        int ll=i,rr=R[i]-1;
        if(arr[i]<0) {
            ans=max(ans,arr[i]*(rmq_qui_min(ll, rr)-rmq_qui_max(l, r)));
        }
        else if(arr[i]>=0) {
            ans=max(ans,arr[i]*(rmq_qui_max(ll, rr)-rmq_qui_min(l, r)));
            }
        }
        printf("%lld\n",ans);
        return 0;
}
*Slime*
关注
专栏目录
[BZOJ3956]Count（单调栈+线段树）
zyf2000
08-20 1037
如果你想拥有你从未有过的东西，那么你必须去做你从未做过的事情。
【ROI2018】抄本【RMQ，分治，单调栈】
ssllyr
08-20 155
ST表，RMQ
POJ2452---Sticks Problem(单调栈+RMQ,方法不够优秀)
Alex
05-15 1352
Description Xuanxuan has n sticks of different length. One day, she puts all her sticks in a line, represented by S1, S2, S3, …Sn. After measuring the length of each stick Sk (1 <= k <= n), she finds
POJ 2452 Sticks Problem ★ (单调栈+RMQ)
weixin_30279671的博客
02-20 141
题目大意：给出一串数，找到最长的一个连续子区间，使得区间的头元素为区间内最小值，末元素为区间内最大值。长度L<=50000 挺好的一道题，自己没想出来T T……看题解才受到了启发…… 用单调栈，预处理所有点的一个right[i]，表示i点向后扩展到的最远的以height[i]为最小值的区间。 然后用RMQ求每个区间的最大值的位置。(这里我用的线段树实现的……不会ST，神牛鄙...
二分、RMQ/单调栈 Codeforces Round #686 (Div. 3) F题
weixin_44745441的博客
04-09 145
二分、RMQ/单调栈 Codeforces Round #686 (Div. 3) F题 题意： 将数组恰分成三段，第一段的最大值 = 第二段的最小值 = 第三段的最大值 思路： 看到有博主用单调栈做，看着还挺繁琐的 然后学着用二分,RMQ做了一下 如何二分？ 满足单调性 区间最大值随区间长度增大而增大 区间最小值随区间长度增大而减小 先枚举第一个分界点，然后二分第二个分界点， 如果max1 < min1 || max1 < max2 说明第二个分界点应该往右移，让最小值更小点，第二个最大值更
leetcode - 1673 - 查找最有竞争力的子序列 - RMQ - 单调栈
闪电彬彬的博客
12-03 697
文章目录题目描述题目代码题目剖析&信息挖掘解题思路方法一 模拟构造法分析思路注意知识点复杂度参考代码实现方法二 有序栈构造法分析思路注意知识点复杂度参考代码实现 题目描述 https://leetcode-cn.com/problems/find-the-most-competitive-subsequence 给你一个整数数组 nums 和一个正整数 k ，返回长度为 k 且最具 竞争力 的 nums 子序列。 数组的子序列是从数组中删除一些元素（可能不删除元素）得到的序列。 在子序列 a 和
POJ 2452 Sticks Problem
weixin_30955341的博客
10-08 148
RMQ+二分。。。。枚举 i，找比 i 小的第一个元素，再找之间的第一个最大元素。。。。。 Sticks Problem Time Limit:6000MS Memory Limit:65536K Total Submissions:9338 Accepted:2443 Descr...
[HDU 5696] 区间的价值 （单调栈+RMQ）
mysterious
10-22 606
链接HDU 5696题意给出一个长度为n（1 <= n <= 100000）的序列，区间权值为区间最大值乘以区间最小值，输出长度为1到n的区间的最大权值。题解先利用单调栈算出以a[i]为最小值的最大区间延伸，设该区间宽度为L，则更新ans[L]（这里用到st表查询该区间最大值），最后从宽度较大的区间刷新宽度较小的区间的长度，即为答案。为什么是对的，可以证明一下，从结果考虑，宽度为k的区间的最优值一定
单调栈巧解柱状图最大矩形
Desgard_Duan
12-27 351
预计阅读时间：11 分钟这几天群里打卡的几道题都是十分经典的面试题，经典是因为这些题都是一题多解的。在这些高效的解法中，单调栈是一个很有技巧的解法，所以这一次我们来聊聊这个单调栈。所谓...
算法学习 （门徒计划）4-2 单调栈（Monotone-Stack）及经典问题 学习笔记
ex_xyz的博客
07-22 967
**学习总结（学完后记录）:** - 单调栈是取消了出队功能的单调队列，单调栈不关注区间内最值 - 单调栈是为了关注新元素如何将旧元素序列一分为，关注新值的前一个值或者后一个值 - 单调栈常用于寻找值的区间跨度（某个值之后间隔多少会出现更大或更小的值） - 单调栈的出元素的方式仅从栈顶出栈 - （额外知识）算法题是为了练习思维模式。
笔记——单调队列&&单调栈优化DP
qq_42421714的博客
12-08 712
众所周知 动态规划 的 题 往往 推了a long time 但是o(n^3) 于是就自闭了 所以我们有了 单调队列和栈 这种东西 神奇的单调队列 有这么一道题 朴素 o(n^2) 乱搞 o(nlog n)（线段树、RMQ） 然后。。。 单调队列 o(n) 对，你没有看错，就是一遍 其实是o(2n)?! 单调队列 用一个东西（栈、队列、数组。。。随君所好） 然后， 解释都在注释里 #include...
[HDU 5875] Function （单调栈/（RMQ+二分））
mysterious
09-12 352
链接HDU 5875题意2016大连站网赛的1008。 给出一个长度为N的序列，和Q组询问，对每组询问[l, r]，输出a[l] % a[l+1] % … % a[r]，l等于r的时候输出a[l]即可。题解这题网上貌似有各种解法花式AC，这里给出两种。第一种是预处理+暴力，对序列a，对a[i]求出其右侧第一个小于等于a[i]的值的下标，因为大于某个余数的值是没有意义的，在查询的时候可以加速计算，跳
【2019牛客暑期多校训练营 第一场 A题 Equivalent Prefixes】【单调栈】【RMQ+二分】
流水
07-22 135
题目链接： https://ac.nowcoder.com/acm/contest/881/A 题意： 给你a，b两个数列，求最大的ppp满足，任意的1≤l≤r≤p1\leq l\leq r\leq p1≤l≤r≤p有，RMQ(a,l,r)=RMQ(b,l,r)RMQ(a, l, r) = RMQ(b,l,r)RMQ(a,l,r)=RMQ(b,l,r)，注意此处RMQ不是区间最小值的意思，而是区间...
J. Taotao Picks Apples（单调栈, 离线 / RMQ, 二分）
最新发布
Mr_dimple的博客
10-25 386
把对于每个位置的询问修改后的值以及询问编号都挂到每个位置下面，从后往前维护单调递减栈，每次询问后面所有位置中第一个大于 y 的值，就可以二分单调栈中的所有位置，找到第一个大于 y 的值所在位置。但是少考虑了一种情况，就是原来这个位置的值比前面最大值大，那么原数组中该位置是拿的，但是现在修改之后该位置不拿了，所以就要重新计算答案。但这种思路是错的，维护前面的时候可以继承上一位置的状态，但是维护后面的就不能继承后一位置的状态，因为是从前往后拿的，当前位置拿了后面就要找第一个大于当前值的位置，从这个位置来转移。
南昌网络赛-I. Max answer （RMQ+单调栈）
lr7682的博客
05-16 266
题目链接：https://nanti.jisuanke.com/t/38228 题目大意： 给一个n个数的数组，找到其中连续几个数，使得这几个数的和乘上这几个数中的最小值的结果最大。 和poj2796很像，不过poj2796的数列只有正数，这道题有正有负，所以需要分类讨论。 poj2796：http://poj.org/problem?id=2796 本题需要的基础知识： RMQ：https://...
单调队列解决RMQ
Byte97
10-30 750
单调队列解决 区间RMQ
数据结构-单调栈
HeartFireY的博客
06-05 338
单调栈即为满足单调性的栈结构。与栈相似，只允许在一端进行进出操作。 单调栈可以用于寻找下一个最大数，也可寻找下一个最小数，以及建立在这基础上的更高级的模型。 二、单调栈的结构与操作 1.插入操作 将一个元素插入单调栈时，为了维护栈的单调性，需要在保证将该元素插入到栈顶后整个栈满足单调性的前提下弹出最少的元素。 例如，栈中自顶向下的元素为 1,3,5,10,30,50
特殊数据结构：单调栈
橘嘉禾
08-09 181
引言 栈（stack）是很简单的一种数据结构，先进后出的逻辑顺序，符合某些问题的特点，比如说函数调用栈。 单调栈实际上就是栈，只是利用了一些巧妙的逻辑，使得每次新元素入栈后，栈内的元素都保持有序（单调递增或单调递减）。 用简洁的话来说就是：单调栈就是 栈内元素单调递增或者单调递减 的栈，单调栈只能在栈顶操作。 听起来有点像堆（heap）？不是的，单调栈用途不太广泛，只处理一种典型的问题，...
Max answer(单调栈，rmq)
weixin_30871905的博客
07-02 145
Max answer 题意：给n个数（n<=5e5），定义一个区间的值为，区间内最小的值乘区间和。求n个数所有区间中的最大值。 思路：为了考虑到所有的情况，我们可以枚举每个数字作为最小值时，它所产生的区间的最大值，那么对于一个数字作为最小值，通过单调栈，可以找到这个数字最左最右的区间，在这个区间内，可以通过前缀和来求每个区间的最大和 当a[i]>0,用前缀和最大值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值