单调栈+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*
关注
专栏目录
RMQ_jim.rar_RMQ
09-23
《线段树与RMQ：高效解决区间查询问题》 在计算机科学中，Range Minimum Query（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
leetcode - 1673 - 查找最有竞争力的子序列 - RMQ - 单调栈
闪电彬彬的博客
12-03 697
文章目录题目描述题目代码题目剖析&信息挖掘解题思路方法一 模拟构造法分析思路注意知识点复杂度参考代码实现方法二 有序栈构造法分析思路注意知识点复杂度参考代码实现 题目描述 https://leetcode-cn.com/problems/find-the-most-competitive-subsequence 给你一个整数数组 nums 和一个正整数 k ，返回长度为 k 且最具 竞争力 的 nums 子序列。 数组的子序列是从数组中删除一些元素（可能不删除元素）得到的序列。 在子序列 a 和
南昌网络赛-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://...
数据结构-单调栈
HeartFireY的博客
06-05 338
单调栈即为满足单调性的栈结构。与栈相似，只允许在一端进行进出操作。 单调栈可以用于寻找下一个最大数，也可寻找下一个最小数，以及建立在这基础上的更高级的模型。 二、单调栈的结构与操作 1.插入操作 将一个元素插入单调栈时，为了维护栈的单调性，需要在保证将该元素插入到栈顶后整个栈满足单调性的前提下弹出最少的元素。 例如，栈中自顶向下的元素为 1,3,5,10,30,50
二分、RMQ/单调栈 Codeforces Round #686 (Div. 3) F题
weixin_44745441的博客
04-09 145
二分、RMQ/单调栈 Codeforces Round #686 (Div. 3) F题 题意： 将数组恰分成三段，第一段的最大值 = 第二段的最小值 = 第三段的最大值 思路： 看到有博主用单调栈做，看着还挺繁琐的 然后学着用二分,RMQ做了一下 如何二分？ 满足单调性 区间最大值随区间长度增大而增大 区间最小值随区间长度增大而减小 先枚举第一个分界点，然后二分第二个分界点， 如果max1 < min1 || max1 < max2 说明第二个分界点应该往右移，让最小值更小点，第二个最大值更
J. Taotao Picks Apples（单调栈, 离线 / RMQ, 二分）
最新发布
Mr_dimple的博客
10-25 386
把对于每个位置的询问修改后的值以及询问编号都挂到每个位置下面，从后往前维护单调递减栈，每次询问后面所有位置中第一个大于 y 的值，就可以二分单调栈中的所有位置，找到第一个大于 y 的值所在位置。但是少考虑了一种情况，就是原来这个位置的值比前面最大值大，那么原数组中该位置是拿的，但是现在修改之后该位置不拿了，所以就要重新计算答案。但这种思路是错的，维护前面的时候可以继承上一位置的状态，但是维护后面的就不能继承后一位置的状态，因为是从前往后拿的，当前位置拿了后面就要找第一个大于当前值的位置，从这个位置来转移。
rmq.rar_RMQ_RMQ algorithm_RMQ c++
09-19
标题中的"rmq.rar_RMQ_RMQ algorithm_RMQ c++"表明我们将讨论RMQ算法以及其在C++编程语言中的实现。 **RMQ问题定义** RMQ问题的定义是这样的：给定一个长度为n的数列A，我们需要处理多个查询，每个查询询问数列A中...
lca-rmq:RMQ查找LCA的算法的实现
05-15
已完成：天真RMQ，更快RMQ（使用nlogn稀疏表） 待办事项：执行±1 RMQ 天真的RMQ输出： (1(2(4..)(5..))(3(6..)(7..))) indexs : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, values : [1, 2, 4, 2, 5, 2, 1, 3,...
rmq.rar_rmq与众不同_最小值 区间
09-19
《RMQ：与众不同，最小值区间》 在计算机科学领域，特别是算法设计中，Range Minimum Query（RMQ）是一个常见的问题。它涉及到在一个数组中快速查找给定区间内的最小值。RMQ问题对于数据结构和算法的设计至关重要，...
RMQ&LCA;问题
12-04
该ppt讲了一种基于线段树的RMQ的ST算法问题和LCA算法，适合初学者用。
【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不是区间最小值的意思，而是区间...
Max answer(单调栈，rmq)
weixin_30871905的博客
07-02 145
Max answer 题意：给n个数（n<=5e5），定义一个区间的值为，区间内最小的值乘区间和。求n个数所有区间中的最大值。 思路：为了考虑到所有的情况，我们可以枚举每个数字作为最小值时，它所产生的区间的最大值，那么对于一个数字作为最小值，通过单调栈，可以找到这个数字最左最右的区间，在这个区间内，可以通过前缀和来求每个区间的最大和 当a[i]>0,用前缀和最大值...
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的区间的最优值一定
[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]的值的下标，因为大于某个余数的值是没有意义的，在查询的时候可以加速计算，跳
LNSYOJ#204谁是天才【RMQ理解+单调栈】【做题报告】
bangzuan5029的博客
12-08 129
这是一道RMQ水题，因为本蒟蒻居然一A 题目描述 　　 张大牛：“我是天才！” 大肥熊：“你为什么是天才？” 张大牛：“你随便给我一个单词(大小写字母组成)长度为NN，去掉MM个字符后，我能知道字典序最小的字符串是什么样子的” 大肥熊：“换过来，现在假设这个字典序最小的字符串中第aiai个字符在原串中的位置为pospos，那么原串中区间[pos−ki,pos+ki][pos−k...
POJ 2452 Sticks Problem ★ (单调栈+RMQ)
weixin_30279671的博客
02-20 141
题目大意：给出一串数，找到最长的一个连续子区间，使得区间的头元素为区间内最小值，末元素为区间内最大值。长度L<=50000 挺好的一道题，自己没想出来T T……看题解才受到了启发…… 用单调栈，预处理所有点的一个right[i]，表示i点向后扩展到的最远的以height[i]为最小值的区间。 然后用RMQ求每个区间的最大值的位置。(这里我用的线段树实现的……不会ST，神牛鄙...
单调队列单调栈
qq_39811285的博客
03-09 116
单调队列单调栈 单调队列 问题引入 RMQ(x, y)为询问数组[x, y]区间内部最小值，如: RMQ(0, 3) = 1 0 1 2 3 4 5 6 7 3 1 4 5 2 9 8 12 固定尾部查询区间最小值: RMQ(x, 7), 最少记录几个元素，可以满足RMQ(x, 7)要求 0 1 2 3 4 5 6 7 1 2 8 12 此时即构成了一个单调队列 维护固定结尾的区间最值问题 入队操作： 入队前，把之前破坏单调性元素从队尾移出（维护单调性） 出队
线段树与单调栈算法解题思路：从1到4的官方题解
- 对于子任务3和4，利用单调栈结合RMQ数据结构，可以减少计算量，维护f数组中的最小值，优化到O(n log n)，提高了效率。 4. 斜率优化 (Slope Optimization) 和树链剖分 (Tree Chain Decomposition): - 算法4提到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值