定义
线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。
对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。**
使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN）。而未优化的空间复杂度为2N，因此有时需要离散化让空间压缩。
作用
上面的都是些基本的线段树结构，但只有这些并不能做什么，就好比一个程序有输入没输出，根本没有任何用处。
最简单的应用就是记录线段是否被覆盖，随时查询当前被覆盖线段的总长度。那么此时可以在结点结构中加入一个变量int count；代表当前结点代表的子树中被覆盖的线段长度和。这样就要在插入（删除）当中维护这个count值，于是当前的覆盖总值就是根节点的count值了。
另外也可以将count换成bool cover；支持查找一个结点或线段是否被覆盖。
实际上，通过在结点上记录不同的数据，线段树还可以完成很多不同的任务。例如，如果每次插入操作是在一条线段上每个位置均加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）。
基本操作
C++：
支持以下操作
1 x 若x不存在,插入x
2 x 若x存在,删除x
3 输出当前最小值,若不存在输出-1
4 输出当前最大值,若不存在输出-1
5 x 输出x的前驱,若不存在输出-1
6 x 输出x的后继,若不存在输出-1
7 x 若x存在,输出1,否则输出-1
#include<bits/stdc++.h>
#define inf 1000000000
using namespace std;
int n,m;
struct seg{int l,r,v;}t[3000005];
void build(int k,int l,int r) //建树 k：当前节点下标 线段左为l，线段右为r
{
t[k].l=l;t[k].r=r; //线段左端，线段右端
if(l==r)return; //线段长度为零，结束
int mid=(l+r)>>1; //取线段中点
build(k<<1,l,mid); //k<<1:下标为k节点的左儿子下标，线段左为l，线段右为mid k<<1==k*2
build(k<<1|1,mid+1,r); //k<<1|1:下标为k节点的右儿子下标，线段左为mid+1，线段右为r k<<1|1==k*2+1
}
int mn(int k)
{
if(!t[k].v)return -1;
int l=t[k].l,r=t[k].r;
if(l==r)return l;
if(t[k<<1].v)return mn(k<<1);
else return mn(k<<1|1);
}
int mx(int k)
{
if(!t[k].v)return -1;
int l=t[k].l,r=t[k].r;
if(l==r)return l;
if(t[k<<1|1].v)return mx(k<<1|1);
else return mx(k<<1);
}
void insert(int k,int val)
{
int l=t[k].l,r=t[k].r;
if(l==r){t[k].v=1;return;}
int mid=(l+r)>>1;
if(val<=mid)insert(k<<1,val);
else insert(k<<1|1,val);
t[k].v=t[k<<1].v+t[k<<1|1].v;
}
int find(int k,int val)
{
int l=t[k].l,r=t[k].r;
if(l==r)
{
if(t[k].v)return 1;
return -1;
}
int mid=(l+r)>>1;
if(val<=mid)return find(k<<1,val);
else return find(k<<1|1,val);
}
void del(int k,int val)
{
int l=t[k].l,r=t[k].r;
if(l==r){t[k].v=0;return;}
int mid=(l+r)>>1;
if(val<=mid)del(k<<1,val);
else del(k<<1|1,val);
t[k].v=t[k<<1].v+t[k<<1|1].v;
}
int findpr(int k,int val)
{
if(val<0)return -1;
if(!t[k].v)return -1;
int l=t[k].l,r=t[k].r;
if(l==r)return l;
int mid=(l+r)>>1;
if(val<=mid)return findpr(k<<1,val);
else
{
int t=findpr(k<<1|1,val);
if(t==-1)return mx(k<<1);
else return t;
}
}
int findsu(int k,int val)
{
if(!t[k].v)return -1;
int l=t[k].l,r=t[k].r;
if(l==r)return l;
int mid=(l+r)>>1;
if(val>mid)return findsu(k<<1|1,val);
else
{
int t=findsu(k<<1,val);
if(t==-1)return mn(k<<1|1);
else return t;
}
}
int main()
{
scanf("%d %d",&n,&m);
build(1,0,n);
int opt,x;
for(int i=1;i<=m;i++)
{
scanf("%d",&opt);
switch(opt)
{
case 1:scanf("%d",&x);if(find(1,x)==-1)insert(1,x);break;
case 2:scanf("%d",&x);if(find(1,x)==1)del(1,x);break;
case 3:printf("%d
",mn(1));break;
case 4:printf("%d
",mx(1));break;
case 5:scanf("%d",&x);printf("%d
",findpr(1,x-1));break;
case 6:scanf("%d",&x);printf("%d
",findsu(1,x+1));break;
case 7:scanf("%d",&x);printf("%d
",find(1,x));break;
}
}
return 0;
}
例题
1.
P3372 【模板】线段树 1
思路：基础模板题
代码：
#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;
}
2.
P1502 窗口的星星
思路；使用线段树定下区间后求解
代码：
#include<bits/stdc++.h>
using namespace std;
#define For(i,a,b) for(int i=a;i<=b;++i)
#define Pn putchar('
')
#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;
}