蒟蒻の线段树学习总结

定义

线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。

对于线段树中的每一个非叶子节点$[a,b]$，它的左儿子表示的区间为$[a,(a+b)/2]$，右儿子表示的区间为$[(a+b)/2+1,b]$。因此线段树是平衡二叉树，最后的子节点数目为$N$，即整个线段区间的长度。

使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为$O(logN)$。而未优化的空间复杂度为$2N$，因此有时需要离散化让空间压缩。

应用

最简单的应用就是记录线段是否被覆盖，随时查询当前被覆盖线段的总长度。那么此时可以在结点结构中加入一个变量$intcount$；代表当前结点代表的子树中被覆盖的线段长度和。这样就要在插入（删除）当中维护这个$count$值，于是当前的覆盖总值就是根节点的$count$值了。
另外也可以将$count$换成$boolcover$；支持查找一个结点或线段是否被覆盖。

实际上，通过在结点上记录不同的数据，线段树还可以完成很多不同的任务。例如，如果每次插入操作是在一条线段上每个位置均加$k$，而查询操作是计算一条线段上的总和，那么在结点上需要记录的值为$sum$。
这里会遇到一个问题：为了使所有sum值都保持正确，每一次插入操作可能要更新$O(N)$个$sum$值，从而使时间复杂度退化为$O(N)$。

解决方案是$Lazy$思想：对整个结点进行的操作，先在结点上做标记，而并非真正执行，直到根据查询操作的需要分成两部分。
根据$Lazy$思想，我们可以在不代表原线段的结点上增加一个值$toadd$，即为对这个结点，留待以后执行的插入操作$k$值的总和。对整个结点插入时，只更新$sum$和$toadd$值而不向下进行，这样时间复杂度可证明为$O(logN)$。

对一个$toadd$值为$0$的结点整个进行查询时，直接返回存储在其中的$sum$值；而若对$toadd$不为$0$的一部分进行查询，则要更新其左右子结点的$sum$值，然后把$toadd$值传递下去，再对这个查询本身，左右子结点分别递归下去。时间复杂度也是$O(nlogN)$。

模板

$Code1$：单点修改线段树

#include<bits/stdc++.h>
using namespace std;
const long long N=100010;
int a[N+10];
struct tree{
    int l,r;
    long long pre,add;
}t[4*N+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;
}

$Code2$：区间修改线段树

#include<bits/stdc++.h>
#define ll long long 
using namespace std;
int n,m,a[1000005],mod;
struct node{
	ll sum,l,r,mu,add;
}t[1000005];
ll read(){
	ll x=0;char ch=getchar();
	while(ch<'0'||ch>'9')ch=getchar();
	while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
	return x;
}
void build(ll p,ll l,ll r){
	t[p].l=l,t[p].r=r;t[p].mu=1;
	if(l==r){t[p].sum=a[l]%mod;return ;}
	ll mid=(l+r)>>1;
	build(p*2,l,mid);
	build(p*2+1,mid+1,r);
	t[p].sum=(t[p*2].sum+t[p*2+1].sum)%mod;
}
void spread(ll p){
    t[p*2].sum=(ll)(t[p].mu*t[p*2].sum+((t[p*2].r-t[p*2].l+1)*t[p].add)%mod)%mod;
    t[p*2+1].sum=(ll)(t[p].mu*t[p*2+1].sum+(t[p].add*(t[p*2+1].r-t[p*2+1].l+1))%mod)%mod;//add已经乘过mu啦
	
    t[p*2].mu=(ll)(t[p*2].mu*t[p].mu)%mod;
    t[p*2+1].mu=(ll)(t[p*2+1].mu*t[p].mu)%mod;

	t[p*2].add=(ll)(t[p*2].add*t[p].mu+t[p].add)%mod;
    t[p*2+1].add=(ll)(t[p*2+1].add*t[p].mu+t[p].add)%mod;
    
    t[p].mu=1,t[p].add=0;
}
void add(ll p,ll l,ll r,ll k){
	if(t[p].l>=l&&t[p].r<=r){
		t[p].add=(t[p].add+k)%mod;
		t[p].sum=(ll)(t[p].sum+k*(t[p].r-t[p].l+1))%mod;//只要加上增加的就好
		return ;
	}
	spread(p);
	t[p].sum=(t[p*2].sum+t[p*2+1].sum)%mod;
	ll mid=(t[p].l+t[p].r)>>1;
	if(l<=mid)add(p*2,l,r,k);
	if(mid<r)add(p*2+1,l,r,k);
	t[p].sum=(t[p*2].sum+t[p*2+1].sum)%mod;
	
}
void mu(ll p,ll l,ll r,ll k){
	if(t[p].l>=l&&t[p].r<=r){
		t[p].add=(t[p].add*k)%mod;//比较重要的一步,add要在这里乘上k,因为后面可能要加其他的数而那些数其实是不用乘k的
		t[p].mu=(t[p].mu*k)%mod;
		t[p].sum=(t[p].sum*k)%mod;
		return ;
	}
	spread(p);
    t[p].sum=t[p*2].sum+t[p*2+1].sum;
	ll mid=(t[p].l+t[p].r)>>1;
	if(l<=mid)mu(p*2,l,r,k);
	if(mid<r)mu(p*2+1,l,r,k);
	t[p].sum=(t[p*2].sum+t[p*2+1].sum)%mod;
}
ll ask(ll p,ll l,ll r){
	if(t[p].l>=l&&t[p].r<=r){
		return t[p].sum;
	}
	spread(p);
	ll val=0;
	ll mid=(t[p].l+t[p].r)>>1;
	if(l<=mid)val=(val+ask(p*2,l,r))%mod;
	if(mid<r)val=(val+ask(p*2+1,l,r))%mod;
	return val;
}
int main(){
	cin>>n>>m>>mod;
	for(int i=1;i<=n;i++){
		a[i]=read();
	}
	build(1,1,n);
	for(int i=1;i<=m;i++){
		int ty=read();
		if(ty==1){
			ll cn=read(),cm=read(),cw=read();
			mu(1,cn,cm,cw);
		}else if(ty==2){
			ll cn=read(),cm=read(),cw=read();
			add(1,cn,cm,cw);
		}else {
			ll cn=read(),cm=read();
			cout<<ask(1,cn,cm)<<endl;
		}
    }
}

例题

P1502 窗口的星星

思路：

想象一条扫描线从左扫到右边，只要进入了星星的区域，扫描线上这段区间就可以取到这颗星星的值，等过了区域再减去这颗星星的值。

那就可以用线段树来做啦，每次挪动找出区间的最值更新答案就可以了。

#include<bits/stdc++.h>
using namespace std;
#define For(i,a,b) for(int i=a;i<=b;++i)
#define Pn putchar('\n')
#define llg long long

using namespace std;

const int N=2e4+10;

struct LIS{
    int x,y,id;
}Lis[N*2];

struct Star{
    int x1,x2,y1,y2;
    llg lgt;
    Star(){
        x1=0; x2=0; y1=0; y2=0;
        lgt=0;
    }
}st[N];

vector<int>ads[N];
vector<int>mns[N];

int tot=0,n,m,W,H,x,y;
llg tag[N*4],mx[N*4],ans=0;

void read(int &v){       //读入优化，和输出优化
    v=0; bool fg=0;
    char c=getchar(); if(c=='-')fg=1;
    while(c<'0'||c>'9'){c=getchar(); if(c=='-')fg=1;}
    while(c>='0'&&c<='9'){v=v*10+c-'0',c=getchar();if(c=='-')fg=1;}
    if(fg)v=-v;
}
void read(llg &v){
    v=0; bool fg=0;
    char c=getchar(); if(c=='-')fg=1;
    while(c<'0'||c>'9'){c=getchar(); if(c=='-')fg=1;}
    while(c>='0'&&c<='9'){v=v*10+c-'0',c=getchar();if(c=='-')fg=1;}
    if(fg)v=-v;
}
void write(int x){
    if(x>9)write(x/10);
    int xx=x%10;
    putchar(xx+'0');
}
                        //排序
bool cmpX(const LIS &a,const LIS &b){
    return a.x<b.x;
}
bool cmpY(const LIS &a,const LIS &b){
    return a.y<b.y;
}
                      //线段树操作
void pDown(int o){
    llg tg=tag[o];  tag[o]=0;
    int ls=o<<1,rs=o<<1|1;
    tag[ls]+=tg; tag[rs]+=tg;
    mx[ls]+=tg; mx[rs]+=tg;
}
void Ins(int o,int l,int r,int lx,int rx,llg dt){
    if(lx<=l&&rx>=r){
        mx[o]+=dt; tag[o]+=dt;
        return;
    }
    int m=(l+r)>>1;
    int ls=o<<1,rs=o<<1|1;
    if(tag[o])pDown(o);
    if(lx<=m)Ins(ls,l,m,lx,rx,dt);
    if(rx>m)Ins(rs,m+1,r,lx,rx,dt);
    mx[o]=max(mx[ls],mx[rs]);
}

int main(){
    int T; read(T);
    while(T--){
        tot=0; ans=0;
        memset(tag,0,sizeof(tag));
        memset(mx,0,sizeof(mx));

        read(n); read(W); read(H);
        For(i,1,n){                        //存下星星区域的右上角和左下角
            read(x); read(y); read(st[i].lgt);
            st[i].x1=st[i].x2=st[i].y1=st[i].y2=0;
            Lis[++tot].x=x;
            Lis[tot].y=y,Lis[tot].id=i;

            Lis[++tot].x=x+W-1;
            Lis[tot].y=y-H+1,Lis[tot].id=i;
        }
        Lis[0].x=INT_MIN-10;
        Lis[0].y=INT_MIN-10;

        sort(Lis+1,Lis+tot+1,cmpY);        //分别对X和Y离散化
        int ty=0;
        For(i,1,tot){
            if(Lis[i].y!=Lis[i-1].y)ty++;
            int ID=Lis[i].id;
            if(!st[ID].y2){
                st[ID].y2=ty;
            }else{
                st[ID].y1=ty;
            }
        }

        sort(Lis+1,Lis+tot+1,cmpX);
        int tx=0;
        For(i,1,tot){
            if(Lis[i].x!=Lis[i-1].x)tx++;
            int ID=Lis[i].id;
            if(!st[ID].x1){
                st[ID].x1=tx;
            }else{
                st[ID].x2=tx;
            }
        }

        For(i,1,tx+1){                  //初始化vector
            ads[i].clear();
            mns[i].clear();
        }

        For(i,1,n){
            int lx,rx;          //把星星挂到相应的横坐标上
            lx=st[i].x1;        //ads为加， mns为减
            rx=st[i].x2+1;
            ads[lx].push_back(i);
            mns[rx].push_back(i);
        }
        For(i,1,tx){
            int sz;

            sz=mns[i].size();
            For(j,0,sz-1){           //先减后加
                int ID=mns[i][j];
                int lx,rx;
                lx=st[ID].y2;
                rx=st[ID].y1;
                Ins(1,1,ty,lx,rx,-st[ID].lgt);

            }

            sz=ads[i].size();
            For(j,0,sz-1){
                int ID=ads[i][j];
                int lx,rx;
                lx=st[ID].y2;
                rx=st[ID].y1;
                Ins(1,1,ty,lx,rx,st[ID].lgt);
            }
            ans=max(ans,mx[1]);
        }
        write(ans); Pn;
    }
	return 0;
}