浅谈区间最值操作与历史最值问题

最新推荐文章于 2024-09-01 09:31:31 发布

aga28832

最新推荐文章于 2024-09-01 09:31:31 发布

阅读量923

点赞数 1

原文链接：http://www.cnblogs.com/AKMer/p/10225100.html

版权

浅谈树状数组与线段树：https://www.cnblogs.com/AKMer/p/9946944.html

区间最值问题

以Gorgeous Sequence为例：

对于线段树上每个结点，我们维护最大值，严格次大值，区间和，最大值个数即可。对于修改操作，分为三种情况讨论：

1、如果当前结点的最大值小于等于\(a\)的话，直接退出，因为取\(max\)操作不会对当前区间造成任何影响。

2、如果当前结点的最大值大于\(a\)但是次大值小于等于\(a\)，所以最大值都会被改成\(a\)，其它值不受影响。给当前点打上一个区间与\(a\)取\(min\)的标记和区间然后减去最大值个数乘以最大值与\(a\)的差值。

3、如果当前结点的次大值大于\(a\)，那么就暴力递归它的两个子树继续做。

时间复杂度证明：

首先第一种和第二种情况都是\(O(1)\)的，我们不用考虑。那么对于第三种情况，怎么证明时间复杂度呢？

这个时候，吉如一线段树最重要的思想来了。

不要试着证明每次的复杂度多么多么优秀，总复杂度总会给你一个满意的答案。

我们记录\(fake\)为当前线段树的权值，\(fake\)记录的是所有结点的权值种数和。一开始最多是\(nlogn\)的。

对于第三种情况，意味着当前结点的最大值和次大值都将消失不见，被\(a\)取而代之。也就是说，你递归了多少个结点，\(fake\)的权值就至少会降低多少。\(fake\)最少可以降到\(2n\)（每个结点的权值都只有一种），所以总复杂度是\(O(nlogn)\)的。

于是乎，吉如一线段树处理这种问题的复杂度就是\(O(nlogn)\)的。

那么假如加上加标记呢？我们考虑一下，每次区间加最后终止的结点一共会有\(logn\)个，所以这会使\(fake\)的权值增加\(mlogn\)，最终复杂度还是可以接受的。

时间复杂度：\(O((n+m)logn)\)

空间复杂度：\(O(n)\)

代码如下：

#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long ll;

const int maxn=1e6+5;

int n,m;
int a[maxn];

int read() {
    int x=0,f=1;char ch=getchar();
    for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
    for(;ch>='0'&&ch<='9';ch=getchar())x=x*10+ch-'0';
    return x*f;
}

struct segment_tree {
    ll sum[maxn<<2];
    int mx[maxn<<2],se[maxn<<2];
    int tag[maxn<<2],cnt[maxn<<2];

    void update(int p) {
        sum[p]=sum[p<<1]+sum[p<<1|1];
        mx[p]=max(mx[p<<1],mx[p<<1|1]);
        cnt[p]=(mx[p]==mx[p<<1])*cnt[p<<1];
        cnt[p]+=(mx[p]==mx[p<<1|1])*cnt[p<<1|1];
        if(mx[p]==mx[p<<1])se[p]=se[p<<1];
        else se[p]=mx[p<<1];
        if(mx[p]==mx[p<<1|1])se[p]=max(se[p],se[p<<1|1]);
        else se[p]=max(se[p],mx[p<<1|1]);
    }

    void build(int p,int l,int r) {
        tag[p]=-1;
        if(l==r) {
            sum[p]=mx[p]=a[l];
            se[p]=-1,cnt[p]=1;
            return;
        }
        int mid=(l+r)>>1;
        build(p<<1,l,mid);
        build(p<<1|1,mid+1,r);
        update(p);
    }

    void solve(int p,int limit) {
        if(mx[p]<=limit)return;
        if(se[p]<limit&&limit<mx[p]) {
            sum[p]-=1ll*(mx[p]-limit)*cnt[p];
            mx[p]=limit,tag[p]=limit;return;
        }
        solve(p<<1,limit),solve(p<<1|1,limit);
        update(p);
    }

    void push_down(int p) {
        if(~tag[p]) {
            solve(p<<1,tag[p]);
            solve(p<<1|1,tag[p]);
            tag[p]=-1;
        }
    }

    void Min(int p,int l,int r,int L,int R,int v) {
        if(L<=l&&r<=R) {solve(p,v);return;}
        int mid=(l+r)>>1;push_down(p);
        if(L<=mid)Min(p<<1,l,mid,L,R,v);
        if(R>mid)Min(p<<1|1,mid+1,r,L,R,v);
        update(p);
    }

    int queryMx(int p,int l,int r,int L,int R) {
        if(L<=l&&r<=R)return mx[p];
        int mid=(l+r)>>1,res=0;push_down(p);
        if(L<=mid)res=max(res,queryMx(p<<1,l,mid,L,R));
        if(R>mid)res=max(res,queryMx(p<<1|1,mid+1,r,L,R));
        return res;
    }

    ll querySum(int p,int l,int r,int L,int R) {
        if(L<=l&&r<=R)return sum[p];
        int mid=(l+r)>>1;ll res=0;
        push_down(p);
        if(L<=mid)res+=querySum(p<<1,l,mid,L,R);
        if(R>mid)res+=querySum(p<<1|1,mid+1,r,L,R);
        return res;
    }
}T;

int main() {
    int Test=read();
    while(Test--) {
        n=read(),m=read();
        for(int i=1;i<=n;i++)
            a[i]=read();
        T.build(1,1,n);
        for(int i=1;i<=m;i++) {
            int opt=read(),l=read(),r=read();
            if(!opt) {
                int v=read();
                T.Min(1,1,n,l,r,v);
            }
            if(opt==1)printf("%d\n",T.queryMx(1,1,n,l,r));
            if(opt==2)printf("%lld\n",T.querySum(1,1,n,l,r));
        }
    }
    return 0;
}