线段树的区间最值操作与区间历史最值

最新推荐文章于 2024-05-25 11:28:51 发布
最新推荐文章于 2024-05-25 11:28:51 发布
阅读量1.1k 收藏
点赞数 1
分类专栏： 线段树 文章标签： javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45724872/article/details/111650618
版权

前提知识

基本的线段树写法：
洛谷线段树1
洛谷线段树2

以下是正文

一、区间最值操作

在这里插入图片描述

例题一、

Gorgeous Sequence

本题要求我们实现三个操作
在这里插入图片描述

做法一、

对于第二种和第三种操作我们是已经知道如何写了。

问题就在于第一种操作。

考虑第一种操作是取min
因此当我们这个区间内的最大值 
1.如果比给定的k来得小 那么我们不需要任何操作
2.如果这个k<最大值 但是k > 第二大的值(以下称为次大值)
那么我们只需要将最大值全部变成k,修改一下区间和即可.
3.如果这个k＜最大值 && k < 次大值 
那么我们当前这个结点是处理不了的,直接push_down交给儿子结点
Code
#include <iostream>
#include <cstring>
#define lc (p<<1)
#define rc (p<<1|1)
using namespace std;
typedef long long ll;
const int N = 1100000;
struct Node{
    int L,R,tag;//这个tag是维护区间最值操作的
    ll sum;
    int fir_big,sec_big;
    int fir_num;
}tree[N*4];
int a[N];
inline void push_up(int);
void build_tree(int l,int r,int p){
    //tag的取值是0~2^31-1 因此我们取-1
    tree[p].L=l,tree[p].R=r,tree[p].tag=-1;
    if(l==r){
        tree[p].sum=a[l];
        tree[p].fir_big=a[l];
        tree[p].sec_big=-1;
        tree[p].fir_num=1;
        return;
    }
    int mid = (l+r)>>1;
    build_tree(l,mid,lc);
    build_tree(mid+1,r,rc);
    push_up(p);
}
inline void push_up(int p){
    tree[p].sum=tree[lc].sum+tree[rc].sum;
    if(tree[lc].fir_big==tree[rc].fir_big){
        tree[p].fir_big=tree[lc].fir_big;
        tree[p].fir_num=tree[lc].fir_num+tree[rc].fir_num;
        tree[p].sec_big=max(tree[lc].sec_big,tree[rc].sec_big);
    }else if(tree[lc].fir_big>tree[rc].fir_big){
        tree[p].fir_big=tree[lc].fir_big;
        tree[p].fir_num=tree[lc].fir_num;
        tree[p].sec_big=max(tree[lc].sec_big,tree[rc].fir_big);
    }else{
        tree[p].fir_big=tree[rc].fir_big;
        tree[p].fir_num=tree[rc].fir_num;
        tree[p].sec_big=max(tree[rc].sec_big,tree[lc].fir_big);
    }
}
inline void update(int p,int cnt_val){
    if(cnt_val<tree[p].fir_big){
        //最大值全部变成cnt_val
        tree[p].sum+=(1ll*cnt_val-tree[p].fir_big)*tree[p].fir_num;
        tree[p].fir_big=tree[p].tag=cnt_val;
    }
}
inline void push_down(int p){
    if(~tree[p].tag){
        update(lc,tree[p].tag);
        update(rc,tree[p].tag);
        tree[p].tag=-1;
    }
}
void modify(int p,int l,int r,int cnt_val){
    if(tree[p].L>r||tree[p].R<l||tree[p].fir_big<=cnt_val) return;
    if(tree[p].L>=l&&tree[p].R<=r&&tree[p].sec_big<cnt_val){
        update(p,cnt_val);
        return;
    }
    push_down(p);
    modify(lc,l,r,cnt_val);
    modify(rc,l,r,cnt_val);
    push_up(p);
}
int queryMax(int p,int l,int r){
    if(tree[p].L>r||tree[p].R<l) return 0;
    if(tree[p].L>=l&&tree[p].R<=r){
        return tree[p].fir_big;
    }
    push_down(p);
    return max(queryMax(lc,l,r),queryMax(rc,l,r));
}
ll querySum(int p,int l,int r){
    if(tree[p].L>r||tree[p].R<l) return 0;
    if(tree[p].L>=l&&tree[p].R<=r){
        return tree[p].sum;
    }
    push_down(p);
    return querySum(lc,l,r)+querySum(rc,l,r);
}
#undef lc
#undef rc
int read(){
	int x=0; char ch=0;
	while (!isdigit(ch)) ch=getchar();
	while (isdigit(ch)) x=(x<<3)+(x<<1)+(ch^48), ch=getchar();
	return x;
}
#if 0
这份代码完成三个功能
1.区间最小值操作
2.求区间最大值
3.求区间和
#endif // 0
int main()
{
    int t,n,m;
    t=read();
    while(t--){
        n=read();
        m=read();
        for(int i=1;i<=n;i++){
           a[i]=read();
        }
        build_tree(1,n,1);
        for(int i=1;i<=m;i++){
            int op,x,y,t;
            op=read();
            if(op==0){
                x=read();
                y=read();
                t=read();
                modify(1,x,y,t);
            }else if(op==1){
                x=read();
                y=read();
                printf("%d\n",queryMax(1,x,y));
            }else{
                x=read();
                y=read();
                printf("%lld\n",querySum(1,x,y));
            }
        }
    }
    return 0;
}
做法二、

2021.9.8复习更新另一个代码；
这份代码和上面那种做法不同点在于，他不是维护一个改变的tag，而是维护一个加法的tag；

按照例题二的思路，我们将值分为三种，最大值、次大值、其他值；

维护两个标记，最大值的加法标记，其他值的加法标记；

#include <iostream>
#include <cstring>

#define lc (p<<1)
#define rc (p<<1|1)

using namespace std;

typedef long long ll;

const int N = 1000010;

struct Node{
    int l,r,mx,sec_mx,mx_num;
    int mx_tag,other_tag;
    ll sum;
}tr[N<<2];

int a[N],t,n,m;
void push_down(int p);
int read()
{
    int x=0; char ch=0;
    while (!isdigit(ch)) ch=getchar();
    while (isdigit(ch)) x=(x<<3)+(x<<1)+(ch^48), ch=getchar();
    return x;
}
void push_up(int p){
    tr[p].sum = tr[lc].sum + tr[rc].sum;
    if(tr[lc].mx == tr[rc].mx){
        tr[p].mx = tr[lc].mx;
        tr[p].mx_num = tr[lc].mx_num + tr[rc].mx_num;
        tr[p].sec_mx = max(tr[lc].sec_mx,tr[rc].sec_mx);
    }else if(tr[lc].mx > tr[rc].mx){
        tr[p].mx = tr[lc].mx;
        tr[p].mx_num = tr[lc].mx_num;
        tr[p].sec_mx = max(tr[lc].sec_mx,tr[rc].mx);
    }else{
        tr[p].mx = tr[rc].mx;
        tr[p].mx_num = tr[rc].mx_num;
        tr[p].sec_mx = max(tr[rc].sec_mx,tr[lc].mx);
    }
}
void build(int p,int l,int r){
    tr[p].l = l,tr[p].r = r;
    tr[p].sec_mx = -1;//因为数据范围是从0开始的
    tr[p].mx_tag = tr[p].other_tag = 0;
    if(l == r){
        tr[p].sum = tr[p].mx = a[l];
        tr[p].mx_num = 1;
        return;
    }
    int mid = (l+r) >> 1;
    build(lc,l,mid);
    build(rc,mid+1,r);
    push_up(p);
}
//给这个节点的最大值、其他值加上某些数
void node_update_fun(int p,int mxk,int otherk){
    tr[p].sum += 1ll*mxk*tr[p].mx_num + 1ll*(tr[p].r-tr[p].l+1-tr[p].mx_num)*otherk;
    if(tr[p].sec_mx != -1) tr[p].sec_mx += otherk;
    tr[p].mx  += mxk;
    tr[p].mx_tag += mxk;
    tr[p].other_tag += otherk;
}
void range_min_fun(int p,int l,int r,int k){
    if(k>=tr[p].mx) return;
    if(tr[p].l>=l&&tr[p].r<=r&&tr[p].sec_mx < k){
        node_update_fun(p,k-tr[p].mx,0);
        return;
    }
    push_down(p);
    int mid = (tr[p].l + tr[p].r) >> 1;
    if(r<=mid){
        range_min_fun(lc,l,r,k);
    }else if(l>mid){
        range_min_fun(rc,l,r,k);
    }else{
        range_min_fun(lc,l,mid,k);
        range_min_fun(rc,mid+1,r,k);
    }
    push_up(p);
}
void push_down(int p){
    int mxk = tr[p].mx_tag;
    int otherk = tr[p].other_tag;
    int mx = max(tr[lc].mx,tr[rc].mx);
    //分清楚左右儿子的值到底应该被哪个k所加
    node_update_fun(lc,tr[lc].mx==mx?mxk:otherk,otherk);
    node_update_fun(rc,tr[rc].mx==mx?mxk:otherk,otherk);
    tr[p].mx_tag = tr[p].other_tag = 0;
}
ll query_sum(int p,int l,int r){
    if(tr[p].l>=l&&tr[p].r<=r){
        return tr[p].sum;
    }
    push_down(p);
    int mid = (tr[p].l+tr[p].r)>>1;
    if(r<=mid){
        return query_sum(lc,l,r);
    }else if(l>mid){
        return query_sum(rc,l,r);
    }else{
        return query_sum(lc,l,mid) +
        query_sum(rc,mid+1,r);
    }
}
int query_max(int p,int l,int r){
    if(tr[p].l>=l&&tr[p].r<=r){
        return tr[p].mx;
    }
    push_down(p);
    int mid = (tr[p].l+tr[p].r)>>1;
    if(r<=mid){
        return query_max(lc,l,r);
    }else if(l>mid){
        return query_max(rc,l,r);
    }else{
        return max(query_max(lc,l,mid),
                   query_max(rc,mid+1,r));
    }

}
int main()
{
    t=read();
    while(t--){
        n=read();
        m=read();
        for(int i=1;i<=n;++i) a[i] =read();
        build(1,1,n);
        int op,l,r,k;
        while(m--){
            op=read();
            l=read();
            r=read();
            if(op == 0){
                k=read();
                range_min_fun(1,l,r,k);
            }else if(op == 1){
                 printf("%d\n",query_max(1,l,r));
            }else{
                printf("%lld\n",query_sum(1,l,r));
            }
        }
    }
    return 0;
}
例题二、

BZOJ4695
这题在上一题的基础之上

  • 增加了区间加
  • 区间最大值操作
  • 求区间最小值

根据上一题区间最小值的操作 我们来仿造区间最大值操作

对于区间最小值操作
我们维护:区间最大值及个数、次大值
那么对于区间最大值操作
我们维护:区间最小值及个数、次小值

那么我们就将数分为了三类:最大值、最小值、其他值
对于题目要求的三种修改操作

  • 对于区间加(减),我们直接对这三类数加(减) 即可
  • 对于区间最小值操作以及最大值操作
    思路与例题一处相同。
    此处以区间最大值操作为例
    1.如果最大值比给定的k来得小 那么我们不需要任何操作
    2.如果这个k<最大值 但是k > 次大值
    那么我们只需要将最大值全部变成k,修改一下区间和即可.
    3.如果这个k＜最大值 && k < 次大值
    那么我们当前这个结点是处理不了的,直接push_down交给儿子结点

那么，我们需要维护三个tag

  • 最大值tag
  • 最小值tag
  • 其他值tag

但是这里有个问题，如果一个区间内的数字很少。

	比如只有1个或者2个
	当只有一个数字的时候 那么最大值是等于最小值的
	我们在push_down的时候不要搞错标记
	
	亦或者只有两个数字的时候 有可能发生次大值等于最小值
	也有可能发生次小值等于最大值 
	此时也要注意是哪个标记的作用

还有一个问题，当前节点的最大最小值是从儿子节点取过来的

此处以最大值为例
如果儿子节点不包含最大值 
那么我们给它加的标记应该是其他值的标记(代码中的t3)
如果包含了 那么应该加最大值的标记(代码中的t2)
Code
#include <iostream>
#include <cstdio>
#define lc (p<<1)
#define rc (p<<1|1)
using namespace std;
typedef long long ll;
const int N = 550000;
const int INF = 1e9;
struct Node{
    int L,R;
    ll sum;
    //分别是最小值 最大值 其他值的tag
    int tag1,tag2,tag3;
    //最大值 最小值 次大值 次小值 最大值个数 最小值个数
    int fir_max,fir_min,sec_max,sec_min,mx_num,mn_num;
}tree[N<<2];
int a[N];
void push_up(int p){
    tree[p].sum=tree[lc].sum+tree[rc].sum;
    if(tree[lc].fir_min==tree[rc].fir_min){
        tree[p].fir_min=tree[lc].fir_min;
        tree[p].mn_num=tree[lc].mn_num+tree[rc].mn_num;
        tree[p].sec_min=min(tree[lc].sec_min,tree[rc].sec_min);
    }else if(tree[lc].fir_min<tree[rc].fir_min){
        tree[p].fir_min=tree[lc].fir_min;
        tree[p].mn_num=tree[lc].mn_num;
        tree[p].sec_min=min(tree[lc].sec_min,tree[rc].fir_min);
    }else{
        tree[p].fir_min=tree[rc].fir_min;
        tree[p].mn_num=tree[rc].mn_num;
        tree[p].sec_min=min(tree[rc].sec_min,tree[lc].fir_min);
    }
    if(tree[lc].fir_max==tree[rc].fir_max){
        tree[p].fir_max=tree[lc].fir_max;
        tree[p].mx_num=tree[lc].mx_num+tree[rc].mx_num;
        tree[p].sec_max=max(tree[lc].sec_max,tree[rc].sec_max);
    }else if(tree[lc].fir_max>tree[rc].fir_max){
        tree[p].fir_max=tree[lc].fir_max;
        tree[p].mx_num=tree[lc].mx_num;
        tree[p].sec_max=max(tree[lc].sec_max,tree[rc].fir_max);
    }else{
        tree[p].fir_max=tree[rc].fir_max;
        tree[p].mx_num=tree[rc].mx_num;
        tree[p].sec_max=max(tree[rc].sec_max,tree[lc].fir_max);
    }
}
void build(int p,int l,int r){
    tree[p].L=l,tree[p].R=r;
    tree[p].tag1=tree[p].tag2=tree[p].tag3=0;
    if(l==r){
        tree[p].fir_max=tree[p].fir_min=tree[p].sum=a[l];
        tree[p].sec_max=-INF;
        tree[p].sec_min=INF;
        tree[p].mx_num=tree[p].mn_num=1;
        return;
    }
    int mid = (l+r)>>1;
    build(lc,l,mid);
    build(rc,mid+1,r);
    push_up(p);
}
//t1,t2,t3分别是最小值 最大值 其他值的tag标记
void update(int p,int t1,int t2,int t3){
    //处理sum
    if(tree[p].fir_max==tree[p].fir_min){
        //如果只有一个值(最大值等于最小值)
        //那么将其他值的tag丢掉
        if(t1==t3) t1=t2;
        else if(t2==t3) t2=t1;
        tree[p].sum+=1ll*tree[p].mx_num*t2;
        //else t2=t1;
        //tree[p].sum+=1ll*t1*tree[p].mn_num;
    }
    else{
        tree[p].sum+=1ll*tree[p].mx_num*t2+1ll*tree[p].mn_num*t1+
        (tree[p].R-tree[p].L+1-tree[p].mx_num-tree[p].mn_num)*t3*1ll;
    }
    //处理次大值
    //如果次大值和最小值相等 那么给它加tag1的值
    //否则加tag3的值
    //处理次小值同理
    if(tree[p].sec_max==tree[p].fir_min){
        tree[p].sec_max+=t1;
    }else if(tree[p].sec_max!=-INF){
        tree[p].sec_max+=t3;
    }
    //处理次小值
    if(tree[p].sec_min==tree[p].fir_max){
        tree[p].sec_min+=t2;
    }else if(tree[p].sec_min!=INF){
        tree[p].sec_min+=t3;
    }

    //处理最大值、最小值、以及tag
    tree[p].fir_max+=t2;
    tree[p].fir_min+=t1;
    tree[p].tag1+=t1;
    tree[p].tag2+=t2;
    tree[p].tag3+=t3;
}
void push_down(int p){
    int mx = max(tree[lc].fir_max,tree[rc].fir_max);
    int mn = min(tree[lc].fir_min,tree[rc].fir_min);
    int l1,l2,r1,r2;
    l1=tree[lc].fir_min==mn?tree[p].tag1:tree[p].tag3;
    l2=tree[lc].fir_max==mx?tree[p].tag2:tree[p].tag3;
    update(lc,l1,l2,tree[p].tag3);
    r1=tree[rc].fir_min==mn?tree[p].tag1:tree[p].tag3;
    r2=tree[rc].fir_max==mx?tree[p].tag2:tree[p].tag3;
    update(rc,r1,r2,tree[p].tag3);
    tree[p].tag1=tree[p].tag2=tree[p].tag3=0;
}

//给一个区间[L,R] 加上一个数x
void fun1(int p,int l,int r,int k){
    if(tree[p].L>r||tree[p].R<l) return;
    if(tree[p].L>=l&&tree[p].R<=r){
        update(p,k,k,k);
        return;
    }
    push_down(p);
    fun1(lc,l,r,k);
    fun1(rc,l,r,k);
    push_up(p);
}
//把一个区间[L,R] 里小于x 的数变成x
void fun2(int p,int l,int r,int k){
     if(tree[p].L>r||tree[p].R<l||tree[p].fir_min>=k) return;
     if(tree[p].L>=l&&tree[p].R<=r&&tree[p].sec_min>k){
        update(p,k-tree[p].fir_min,0,0);
        return;
     }
    push_down(p);
    fun2(lc,l,r,k);
    fun2(rc,l,r,k);
    push_up(p);
}
//把一个区间[L,R] 里大于x 的数变成x
void fun3(int p,int l,int r,int k){
    if(tree[p].L>r||tree[p].R<l||tree[p].fir_max<=k) return;
    if(tree[p].L>=l&&tree[p].R<=r&&tree[p].sec_max<k){
        update(p,0,k-tree[p].fir_max,0);
        return;
     }
    push_down(p);
    fun3(lc,l,r,k);
    fun3(rc,l,r,k);
    push_up(p);
}
//求区间[L,R] 的和
ll fun4(int p,int l,int r){
     if(tree[p].L>r||tree[p].R<l) return 0;
     if(tree[p].L>=l&&tree[p].R<=r){
        return tree[p].sum;
     }
     push_down(p);
     return fun4(lc,l,r)+fun4(rc,l,r);
}
//求区间[L,R] 的最大值
int fun5(int p,int l,int r){
    if(tree[p].L>r||tree[p].R<l) return -INF;
    if(tree[p].L>=l&&tree[p].R<=r){
        return tree[p].fir_max;
     }
      push_down(p);
     return max(fun5(lc,l,r),fun5(rc,l,r));
}
//求区间[L,R] 的最小值
int fun6(int p,int l,int r){
    if(tree[p].L>r||tree[p].R<l) return INF;
    if(tree[p].L>=l&&tree[p].R<=r){
        return tree[p].fir_min;
     }
      push_down(p);
     return min(fun6(lc,l,r),fun6(rc,l,r));
}
#undef lc
#undef rc
int read()
{
	int x=0, w=0; char ch=0;
	while (!isdigit(ch)) w|=ch=='-', ch=getchar();
	while (isdigit(ch)) x=(x<<3)+(x<<1)+(ch^48), ch=getchar();
	return w?-x:x;
}
template<class T>
inline void write(T x)
{
     if(x<0) putchar('-'),x=-x;
     if(x>9) write(x/10);
     putchar(x%10+'0');//取出个位
}

int main()
{
    int n;
    n=read();
    for(int i=1;i<=n;i++){
       a[i]=read();
    }
    build(1,1,n);
    int m;
    m=read();
    while(m--){
        int op,l,r,k;
        op=read();
        switch(op){
            case 1:
                l=read();r=read();k=read();
                fun1(1,l,r,k);
                break;
            case 2:
                l=read();r=read();k=read();
                fun2(1,l,r,k);
                break;
            case 3:
                l=read();r=read();k=read();
                fun3(1,l,r,k);
                break;
            case 4:
                l=read();r=read();
                write(fun4(1,l,r));
                putchar('\n');
                break;
            case 5:
                 l=read();r=read();
                 write(fun5(1,l,r));
                 putchar('\n');
                break;
            case 6:
                 l=read();r=read();
                 write(fun6(1,l,r));
                 putchar('\n');
                break;
        }
    }
    return 0;
}
代码二

2021.9.7复习，写了一份新的，我觉得更加适合理解，思路和上面是一致的；

#include <iostream>

using namespace std;

typedef long long ll;

const int N = 5e5+10;

const int INF = 1e9;

#define lc (p<<1)
#define rc (p<<1|1)

struct Node{
    int l,r,mx,mn,mx_num,mn_num,sec_mx,sec_mn;
    ll sum;
    int mx_tag,mn_tag,other_tag;
}tr[N<<2];
int n,m,a[N];
void push_down(int p);

void push_up(int p){
    Node &left = tr[lc],&right = tr[rc],&root = tr[p];
    root.sum = left.sum + right.sum;
    //操作最大值、次大值
    if(left.mx == right.mx){
        root.mx = left.mx;
        root.mx_num = left.mx_num + right.mx_num;
        root.sec_mx = max(left.sec_mx,right.sec_mx);
    }else if(left.mx > right.mx){
        root.mx = left.mx;
        root.mx_num = left.mx_num;
        root.sec_mx = max(left.sec_mx,right.mx);
    }else{
        root.mx = right.mx;
        root.mx_num = right.mx_num;
        root.sec_mx = max(right.sec_mx,left.mx);
    }
    //最小值、次小值
    if(left.mn == right.mn){
        root.mn = left.mn;
        root.mn_num = left.mn_num + right.mn_num;
        root.sec_mn = min(left.sec_mn,right.sec_mn);
    }else if(left.mn < right.mn){
        root.mn = left.mn;
        root.mn_num = left.mn_num;
        root.sec_mn = min(left.sec_mn,right.mn);
    }else{
        root.mn = right.mn;
        root.mn_num = right.mn_num;
        root.sec_mn = min(right.sec_mn,left.mn);
    }
}
//这个方法对某个节点的最大值、最小值、其他值加上某些数
void node_update_fun(int p,int mnk,int mxk,int otherk){
    Node & root = tr[p];
    if(root.mx == root.mn){
        //不应该被其他值的标签所影响,因为这里只有一个值
        if(mnk == otherk) mnk = mxk;
        else mxk = mnk;
        root.sum += 1ll*root.mn_num * mnk;
    }else{
        root.sum += 1ll*root.mn_num * mnk + 1ll*root.mx_num * mxk
        + 1ll*(root.r-root.l+1-root.mn_num-root.mx_num)*otherk;
    }
    //操作次值
    if(root.mx == root.sec_mn){
        root.sec_mn += mxk;
    }else if(root.sec_mn != INF){
        root.sec_mn += otherk;
    }
    if(root.mn == root.sec_mx){
        root.sec_mx += mnk;
    }else if(root.sec_mx != -INF){
        root.sec_mx +=otherk;
    }
    root.mx += mxk;
    root.mn += mnk;

    root.mx_tag += mxk;
    root.mn_tag += mnk;
    root.other_tag += otherk;
}
void range_max_fun(int p,int l,int r,int k){
    Node &root = tr[p];
    if(root.mn >= k) return;
    if(root.l>=l&&root.r<=r&&root.sec_mn > k){
        node_update_fun(p,k-root.mn,0,0);
        return;
    }
    push_down(p);
    int mid = (root.l + root.r) >> 1;
    if(r<=mid){
        range_max_fun(lc,l,r,k);
    }else if(l>mid){
        range_max_fun(rc,l,r,k);
    }else{
        range_max_fun(lc,l,mid,k);
        range_max_fun(rc,mid+1,r,k);
    }
    push_up(p);
}
void range_min_fun(int p,int l,int r,int k){
    Node &root = tr[p];
    if(root.mx <= k) return;
    if(root.l>=l&&root.r<=r&&root.sec_mx<k){
        node_update_fun(p,0,k-root.mx,0);
        return;
    }
    push_down(p);
    int mid = (root.l + root.r) >> 1;
    if(r<=mid){
        range_min_fun(lc,l,r,k);
    }else if(l>mid){
        range_min_fun(rc,l,r,k);
    }else{
        range_min_fun(lc,l,mid,k);
        range_min_fun(rc,mid+1,r,k);
    }
    push_up(p);
}
void range_add_fun(int p,int l,int r,int k){
    Node & root = tr[p];
    if(root.l>=l&&root.r<=r){
        node_update_fun(p,k,k,k);
        return;
    }
    push_down(p);
    int mid = (root.l + root.r) >> 1;
    if(r<=mid){
        range_add_fun(lc,l,r,k);
    }else if(l>mid){
        range_add_fun(rc,l,r,k);
    }else{
        range_add_fun(lc,l,mid,k);
        range_add_fun(rc,mid+1,r,k);
    }
    push_up(p);
}
ll query_sum(int p,int l,int r){
    Node & root = tr[p];
    if(root.l>=l&&root.r<=r){
        return root.sum;
    }
    push_down(p);
    int mid = (root.l + root.r) >> 1;
    if(r<=mid){
        return query_sum(lc,l,r);
    }else if(l>mid){
        return query_sum(rc,l,r);
    }else{
        return query_sum(lc,l,mid)+
        query_sum(rc,mid+1,r);
    }
}
int query_max(int p,int l,int r){
    Node & root = tr[p];
    if(root.l>=l&&root.r<=r){
        return root.mx;
    }
    push_down(p);
    int mid = (root.l + root.r) >> 1;
    if(r<=mid){
        return query_max(lc,l,r);
    }else if(l>mid){
        return query_max(rc,l,r);
    }else{
        return max(query_max(lc,l,mid),
        query_max(rc,mid+1,r));
    }
}
int query_min(int p,int l,int r){
    Node & root = tr[p];
    if(root.l>=l&&root.r<=r){
        return root.mn;
    }
    push_down(p);
    int mid = (root.l + root.r) >> 1;
    if(r<=mid){
        return query_min(lc,l,r);
    }else if(l>mid){
        return query_min(rc,l,r);
    }else{
        return min(query_min(lc,l,mid),
        query_min(rc,mid+1,r));
    }
}
void push_down(int p){
    int mx = max(tr[lc].mx,tr[rc].mx);
    int mn = min(tr[lc].mn,tr[rc].mn);
    int mxk = tr[p].mx_tag,mnk = tr[p].mn_tag,otherk=tr[p].other_tag;
    node_update_fun(lc,tr[lc].mn==mn?mnk:otherk,
                    tr[lc].mx==mx?mxk:otherk,
                    otherk
                    );
    node_update_fun(rc,tr[rc].mn==mn?mnk:otherk,
                    tr[rc].mx==mx?mxk:otherk,
                    otherk
                    );
    tr[p].mx_tag = tr[p].mn_tag = tr[p].other_tag = 0;
}

void build(int p,int l,int r){
    tr[p].l = l,tr[p].r = r;
    tr[p].mn_tag = tr[p].mx_tag = tr[p].other_tag = 0;
    tr[p].mx = tr[p].sec_mx = -INF;
    tr[p].mn = tr[p].sec_mn = INF;
    if(l==r){
        tr[p].sum = tr[p].mn = tr[p].mx = a[l];
        tr[p].mx_num = tr[p].mn_num = 1;
        return;
    }
    int mid = (l+r) >> 1;
    build(lc,l,mid);
    build(rc,mid+1,r);
    push_up(p);
}

int main()
{
    std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    cin >> n;
    for(int i=1;i<=n;++i) cin >> a[i];
    build(1,1,n);
    cin >> m;
    int op,l,r,k;
    while(m--){
        cin >> op >> l >> r;
        switch(op){
            case 1:
                cin >> k;
                range_add_fun(1,l,r,k);
                break;
            case 2:
                cin >> k;
                range_max_fun(1,l,r,k);
                break;
            case 3:
                cin >> k;
                range_min_fun(1,l,r,k);
                break;
            case 4:
                cout << query_sum(1,l,r) <<'\n';
                break;
            case 5:
                cout << query_max(1,l,r) << '\n';
                break;
            case 6:
                cout << query_min(1,l,r) << '\n';
                break;
        }
    }
    return 0;
}

例题三、

待完成…

荼白777
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
线段树 3（区间最值与历史最值）【线段树】
//(^ o ^)//
10-21 491
>Link luogu P6242 >Description >解题思路 这个大佬写的好好%% 对于每个节点，我们维护：当前最大值，当前次大值，历史最大值，历史次大值（这道题好像不用用到这个），当前最大值的个数，区间和，和四个懒标记 四个懒标记分别为： lazy1：当前最大值要加上的值 lazy2：历史最大值要加上的值 lazy3：当前非最大值要加上的值 lazy4：历史非最大值要加上的值 加操作：全部都加上 取min操作：考虑要取的min值valvalval的不同情况。valv
线段树--区间求和，最大值，最小值
Caroling0的博客
07-18 1973
线段是图文讲解，简单实现
线段树----logn时间维护查询区间和/最大值/最小值
阿也的博客
07-27 1274
线段树是算法竞赛中常用的用来维护 区间信息 的数据结构。线段树可以在 O(\log N) 的时间复杂度内实现单点修改、区间修改、区间查询（区间求和，求区间最大值，求区间最小值）等操作。
【知识点】浅入线段树与区间最值问题
最新发布
Macw07的博客
05-25 913
线段树的数据结构、基本原理、构建方法、区间查询和更新操作，以及其在解决区间最值问题和进行优化（如懒标记）中的应用和代码实现。
（一）线段树入门--区间最值查询
youcanyouup
07-28 2209
线段树 描述 区间最值查询问题 模板 一棵看上去很唬人的树 一些比较酷的操作 这是一篇入门文章，不过需要你知道啥是二叉树，并且知道递归，本文会持续更新，时间看作者心情。 线段树描述分类：二叉树搜索树 节点结构：struct node { int l,r;//范围【l,r】 }tr[100];解决问题：区间问题 图示：（显示了节点分布） 叶子结点：树的最小节点。如【1,1】,【2
区间信息维护与查询【线段树 】 - 原理1 线段树的基本操作
谢谢你们的关注
11-29 380
区间信息维护与查询【线段树 】 - 原理1 线段树的基本操作
区间取min线段树的一种奇妙势能分析
一位蒟蒻的小博客
04-02 1398
比如这题 设势函数=每个点所管区间内互异值的个数总和 一开始势能最大nlogn 操作1使得势能最多增加logn 操作2我们这样处理：每个点记录一下最大值和次大值，若x大于最大值退掉，若x在最大值与次大值之间则打一个tag，若x小于次大值则递归下去。 可以发现，每次递归下去时势函数都至少减1，这时我们要花费向下走左右子树，共2的时间。那么，总的时间复杂度就控制在了势函数最大值(n+m) lo
线段树 区间更新 区间求和以及最值
ACMer_AK的博客
07-23 3673
#include #include #include #include #include #include #define MAXN 100010 #define inf 0x3f3f3f3f using namespace std; struct node{ int l,r;//区间[l,r] int add;//区间的延时标记 int sum;//区间和
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
03-05
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
RMQ求区间最值（最大最小）
08-28
区间最值查询（Range Minimum/Maximum Query，简称RMQ）是数据结构和算法领域中一个经典的问题。在处理大规模数据时，我们往往需要快速查询一个序列或者数组在某个连续子区间内的最大值或最小值，而RMQ算法就是为此...
线段树的一种实现
12-25
线段树在处理区间最值、区间加减等操作时效率极高，且空间复杂度相对较低。 标题“线段树的一种实现”暗示了我们将探讨线段树的基本构建和操作方法。这个实现可能是用C++、Java或Python等编程语言完成的，它强调的...
线段树入门
05-03
在实际应用中，线段树可以扩展以支持更复杂的问题，比如区间加权求和、区间最值查询等。通过在节点上增加额外的数据域和更新规则，线段树可以灵活地适应各种需求，从而在算法设计中发挥重要作用。总的来说，线段树是...
【地狱副本】数据结构之线段树Ⅲ——区间最值/赋值/修改/历史值操作（HDU5306，Tyvj 1518，【清华集训2015】V，HDU6315，HDU1828，POJ3162）
08-25 538
超难线段树应用！！查找历史值好难啊！！Orz
线段树详解(附例题)
qq_61832536的博客
07-15 258
如图所示，则第k-1层有n-2个叶子结点和1个非叶子结点，共n-1个结点，则第k层应有2(n-1)个空间结点，由满二叉树性质可知，前k-2层应有n-2个结点空间，所以总空间为。树上的操作大多与树高相关。举个例子，记录区间[1,2]最大值max=3，当其子区间[1,1]值改为5时，则父区间[1,2]的最大值也因发生改变，因此需要回归改变区间[1,2]的最大值为5。假设有数组a，现有2种操作，一种是将数组中区间[l,r]的值改为k，另一种是查询区间[l,r]的和，并且这2中操作次数足够多，我们应该怎么解决呢？
线段树习题
06-15 276
维护什么 bzoj1798维护序列 原理lazy标记 一个是乘，一个是加 加不影响乘 乘要让加的标记也乘 开longlong bzoj1858 先维护1和0的数量即和 在区间内左侧1和右侧1及区间内最多1 覆盖标记和取反标记，覆盖可以覆盖取反。 bzoj3888 对于每个时间段按y从小到大往里覆盖 如果为空就加一 不为空就返回 用离散化 联想到一道求城市轮廓线的题
高级数据结构之线段树，区间求和，最大值最小值
haruakagasukida的博客
11-01 427
高级数据结构，线段树，区间操作
【自用】线段树 区间最小值
各种问题卡住我
01-07 2236
参考http://www.cnblogs.com/TenosDoIt/p/3453089.html概述是一种平衡二叉树，在每个节点保存一条线段（一个数组区间），主要用于高效解决连续区间的动态查询，基本能保持每个操作的复杂度为O（logn）。例子问题描述：从数组arr[0…n-1]中查找某个区间内的最小值，其中数组大小固定，但是数组中的元素的值随时可以更新。 最简单的解法：遍历数组区间找到最小值
【线段树】 求区间最小值以及区间最小值
huihui1094667985的博客
04-13 1644
//这是第一个模板#include #define MAX 65535 #define INFINITY 65535 #define min(a,b) a<b?a:b struct Node { int val; }segtree[MAX]; void buildtree(int root, int arr[],int istart,int iend ) { if(istart==iend)
黑白博弈 | 线段树（维护区间最小值&&最大值）
谦的博客
02-26 1314
黑白博弈 题目 分析 代码 题目 题目链接：黑白博弈 分析 首先我们通过读题：单点修改、查询很容易发现这道题可以用线段树解决，既然决定了用线段树解决，那么我们需要确定以下几个要素： 1：使用线段树维护什么？ 2：如何通过线段树维护的数据获得我们需要的答案？ Question1: 我们需要用利用线段树维护什么? 通过题目要求我们得知在进行查询操作时需要查询的数据是当前白块区间所有连续的白块数量，也就是说只要知道了该白块区间两端的黑块下标，我们就可以通过这两个黑块下标计算得出该区间的白块个数。 那么
用线段树算区间最值代码
05-28
以下是一个用线段树算区间最值的示例代码，以查询区间最小值为例： ```cpp #include <cstdio> #include <algorithm> using namespace std; const int MAXN = 100005; int n, m; int a[MAXN]; struct Node { int l, r, minn; } tr[MAXN*4]; // 建立线段树 void build(int u, int l, int r) { tr[u].l = l, tr[u].r = r; if (l == r) { // 叶子节点 tr[u].minn = a[l]; return; } int mid = (l + r) >> 1; build(u<<1, l, mid); build(u<<1|1, mid+1, r); tr[u].minn = min(tr[u<<1].minn, tr[u<<1|1].minn); } // 查询区间最小值 int query(int u, int ql, int qr) { if (ql <= tr[u].l && tr[u].r <= qr) { // 完全包含 return tr[u].minn; } int mid = (tr[u].l + tr[u].r) >> 1; int res = 0x3f3f3f3f; // 初始化为一个极大值 if (ql <= mid) res = min(res, query(u<<1, ql, qr)); // 左子区间有交集 if (qr > mid) res = min(res, query(u<<1|1, ql, qr)); // 右子区间有交集 return res; } int main() { scanf("%d%d", &n, &m); for (int i = 1; i <= n; i++) { scanf("%d", &a[i]); } build(1, 1, n); // 建立线段树 while (m--) { int l, r; scanf("%d%d", &l, &r); printf("%d\n", query(1, l, r)); } return 0; } ``` 这段代码中，建立线段树的过程采用递归方式实现，查询区间最小值的过程也采用递归方式实现。对于每个节点，维护该节点对应区间的最小值。查询区间最小值的过程，采用线段树的递归查询方式，将查询区间划分成若干个离散的单元，并依次查询每个单元，最终得到查询区间的最小值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值