题解 P3372 【【模板】线段树 1】

· · 题解

来水一波题解

来首先简介一下线段树,就是比较niubi的一个数据结构,类似本题,可以维护区间加,区间查找等操作,其余还有区间乘,区间最大值,甚至最大连续子段和等等好多操作……

貌似长这样:(图片来自互联网)

-线段树的存储

线段树要用结构体存储

struct tree{
    int l,r;
    long long pre,add;
}t[4*maxn+2];

pre代表该节点维护的值,l,r代表该节点维护的区间范围 至于add涉及到一个叫懒标记的东西,后面会说……

-建树

所谓建树,就是把数组a[1-n],放到线段树中

在线段树中,从图里也可以看出来,对于一个区间(编号为p),他的左儿子为2p,右儿子为2p+1,so伟大的建树操作就出现了

void bulid(int p,int l,int r){
    t[p].l=l;t[p].r=r;//以p为编号的节点维护的区间为l到r
    if(l==r){//l=r的话,这个区间就只有一个数,直接让区间维护的值等于a[i]
        t[p].pre=a[l];
        return;
    }//否则维护的值等于左儿子加右儿子
    int mid=l+r>>1;
    bulid(p*2,l,mid);
    bulid(p*2+1,mid+1,r);
    t[p].pre=t[p*2].pre+t[p*2+1].pre;
} 

-懒标记

懒标记是一个神奇的东西,为什么叫懒标记,因为它比较懒 懒标记的精髓就是打标记和下传操作,由于我们要做的操作是区间加一个数,所以我们不妨在区间进行修改时为该区间打上一个标记,就不必再修改他的儿子所维护区间,等到要使用该节点的儿子节点维护的值时,再将懒标记下放即可,可以节省很多时间,对于每次区间修改和查询,将懒标记下传,可以节省很多时间

void spread(int p){
    if(t[p].add){//如果懒标记不为0,就将其下传,修改左右儿子维护的值
        t[p*2].pre+=t[p].add*(t[p*2].r-t[p*2].l+1);
        t[p*2+1].pre+=t[p].add*(t[p*2+1].r-t[p*2+1].l+1);
        t[p*2].add+=t[p].add;//为该节点的左右儿子打上标记
        t[p*2+1].add+=t[p].add;
        t[p].add=0;//下传之后将该节点的懒标记清0
    }
}

-区间修改

考虑将一个区间加上一个数,我们可以从根节点不断向下查找,当发现我们要修改的区间覆盖了当前节点时,我们就把这个区间给修改,并打上懒标记(由于懒标记存在,我们就不必再修改他的儿子节点),否则下传懒标记,继续向下找

void change(int p,int x,int y,int z){
    if(x<=t[p].l && y>=t[p].r){//被覆盖的话,就对其进行修改
        t[p].pre+=(long long)z*(t[p].r-t[p].l+1);
        t[p].add+=z;//打上懒标记
        return;
    }
    spread(p);//如果发现没有被覆盖,那就需要继续向下找,考虑儿子所维护的区间可能因为懒标记的存在而没有修改,因此将懒标记下放
    int mid=t[p].l+t[p].r>>1;
    if(x<=mid) change(p*2,x,y,z);//如果要修改的区间覆盖了左儿子,就修改左儿子
    if(y>mid) change(p*2+1,x,y,z);//右儿子同理
    t[p].pre=t[p*2].pre+t[p*2+1].pre;//最终维护的值等于左儿子的值+右儿子的值   
}

-区间查询

考虑询问一个区间的和,依旧是从根节点向下查找,当发现该节点被覆盖时,就返回维护的值,否则下传懒标记,查询左右儿子,累加答案

long long ask(int p,int x,int y){
    if(x<=t[p].l && y>=t[p].r) return t[p].pre;//如果被覆盖,就返回维护的值
    spread(p);//下传懒标记,并查询左右儿子
    int mid=t[p].l+t[p].r>>1;
    long long ans=0;
    if(x<=mid) ans+=ask(p*2,x,y);
    if(y>mid) ans+=ask(p*2+1,x,y);//累加答案,返回左右儿子的和
    return ans;
}

AC代码来一波

#include<bits/stdc++.h>

using namespace std;

const int maxn=100010;

int a[maxn+2];

struct tree{
    int l,r;
    long long pre,add;
}t[4*maxn+2];

void bulid(int p,int l,int r){
    t[p].l=l;t[p].r=r;
    if(l==r){
        t[p].pre=a[l];
        return;
    }
    int mid=l+r>>1;
    bulid(p*2,l,mid);
    bulid(p*2+1,mid+1,r);
    t[p].pre=t[p*2].pre+t[p*2+1].pre;
} 

void spread(int p){
    if(t[p].add){
        t[p*2].pre+=t[p].add*(t[p*2].r-t[p*2].l+1);
        t[p*2+1].pre+=t[p].add*(t[p*2+1].r-t[p*2+1].l+1);
        t[p*2].add+=t[p].add;
        t[p*2+1].add+=t[p].add;
        t[p].add=0;
    }
}

void change(int p,int x,int y,int z){
    if(x<=t[p].l && y>=t[p].r){
        t[p].pre+=(long long)z*(t[p].r-t[p].l+1);
        t[p].add+=z;
        return;
    }
    spread(p);
    int mid=t[p].l+t[p].r>>1;
    if(x<=mid) change(p*2,x,y,z);
    if(y>mid) change(p*2+1,x,y,z);
    t[p].pre=t[p*2].pre+t[p*2+1].pre;   
}

long long ask(int p,int x,int y){
    if(x<=t[p].l && y>=t[p].r) return t[p].pre;
    spread(p);
    int mid=t[p].l+t[p].r>>1;
    long long ans=0;
    if(x<=mid) ans+=ask(p*2,x,y);
    if(y>mid) ans+=ask(p*2+1,x,y);
    return ans;
}

int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    scanf("%d",&a[i]);
    bulid(1,1,n);
    for(int i=1;i<=m;i++)
    {
        int q,x,y,z;
        scanf("%d",&q);
        if(q==1){
            scanf("%d%d%d",&x,&y,&z);
            change(1,x,y,z);
        }
        else {
            scanf("%d%d",&x,&y);
            cout<<ask(1,x,y)<<endl;
        }
    }
    return 0;
}

然后你会发现: