普通线段树

线段树原理

（证明）

线段树是一种维护序列操作的二叉树数据结构。

线段树存在以下五个操作：

1. build：创建一颗线段树
2. push_up：根据子节点计算父节点的信息
3. push_down：根据父节点的修改标记去更新子节点的信息（用于区间修改）
4. push：修改（分为单点修改和区间修改）
5. find：查询

可以证明，线段树是一颗Leafy tree，也就是说，它的非叶子点一定有左右儿子。

线段树的节点对应着序列上的一段区间。对于一段长度为$n$的区间，根节点对应着$[1,n]$，对于一个对应区间为$[l,r]$的节点，令$mid=\lfloor \frac{l+r}{2}\rfloor$，则它的左儿子对应的区间为$[l,mid]$，右儿子对应的区间为$[mid+1,r]$。

普通线段树一个节点用一个结构体表示：

struct node{int l,r;节点对应的区间范围int info;节点存储的某些信息
};

通常我们把一颗线段树用堆式存储在数组里。即根节点编号为$1$，编号为$u$的节点左儿子为$2\cdot u$，右儿子为$2\cdot u+1$。相应的，$u$节点的父亲编号为$\lfloor \frac{u}{2}\rfloor$。

对于对应区间为$[1,N]$的一颗线段树，可以证明，它用到的空间可以存储在大小为$4N$的数组以内。
因此我们通常这样定义一颗线段树：

const int N=1e5;
struct node{int l,r;int info;//...
}t[N<<2];

习惯上线段树对应的区间是从$1$开始编号的，例如$[1,n]$。但其实线段树也可以维护从$0$开始编号的区间。但是如果区间从负数开始编号，则需要对线段树的实现进行特殊处理，或者增加一个偏移量。（这是由于c++默认的int取整方式不是向下取整，而是向零取整）

需要尤其注意的是，对应的区间为$[0,n]$的一颗线段树，事实上对应的区间长度为$n+1$，因此空间需要开到$4(n+1)$，而不是$4n$。

可以证明，线段树大概有$O({\log }_{2}n)$层。

P3374

const int N=5e5;
struct node{int l,r;int sum; 
}t[N<<2];

建树（build）

然后我们通过build创建一颗线段树。（默认线段树维护一个全$0$序列）
build(u,l,r)递归到节点$u$，设置这个节点的对应的区间为$[l,r]$，然后递归到它的左右儿子。

void build(int u,int l,int r) {t[u]={l,r,0};if(l==r) return ;int mid=l+r>>1;build(u<<1,l,mid);build(u<<1|1,mid+1,r);
}

每个节点只被创建一次，因此build的复杂度是$O(n\log n)$

上传标记（push_up）

push_up(u)表示$u$为父亲，现在用$u$的左右儿子的信息来合并$u$的信息。
我们约定调用push_up(u)的前提是，$u$必须要有左右儿子。

在这个题目里面，我们维护的是区间和。

void push_up(int u) {t[u].sum=t[u<<1].sum+t[u<<1|1].sum;
}

单点修改（push）

想要在线段树上做单点修改，我们需要根节点一直递归下去到对应为止的节点，并更新递归路径上所有节点的信息。

push(u,pos,val)，表示目前在编号为$u$的节点，修改操作为，给$pos$位置的值增加$val$。
我们从根节点出发开始递归，我们递归进入编号为$u$的节点，前提是$pos\in [l_u,r_u]$。

单点修改的push函数具体是这样运作的：

• 若$u$为叶子，因为$pos\in [l_u,r_u]$才会递归下来，说明$pos=l_u=r_u$，进行修改
• 若$u$不是叶子，要递归到$pos$对应方向的儿子，然后push_up(u)，更新$u$节点的信息
  这里能够push_up(u)，是因为$u$有儿子，说明$u$不是叶子。

void push(int u,int p,int val) {if(t[u].l==t[u].r&&t[u].r==p) t[u].sum+=val;else {int mid=t[u].l+t[u].r>>1;if(p<=mid) push(u<<1,p,val);if(mid<p) push(u<<1|1,p,val);第二个if(mid<p)可以改为else，但是由于区间修改不能这么写，习惯上不这么写。push_up(u);}
}

这样我们的递归路线最终形成了线段树上一条从根节点到叶子节点的路径：

单点修改的复杂度与树高有关，因此复杂度为$O(\log n)$

查询（find）

查询操作find(u,l,r)表示目前递归到了节点$u$，要查询区间$[l,r]$的和。
能够递归到节点$u$，前提是$u$与$[l,r]$有交。

find函数具体是这样运作的：

• 如果节点$u$包含于$[l,r]$，则返回$su{m}_u$
• 否则：令$mid=\lfloor \frac{l+r}{2}\rfloor$
• 若$l\le mid$，说明区间与左儿子有交，递归到左儿子
  之所以$l\le mid$就说明区间与左儿子有交，是因为保证了$[l,r]$与$u$有交，右儿子同理。
• 若$mid<r$，说明区间与右儿子有交，递归到右儿子

int find(int u,int l,int r) {if(l<=t[u].l&&t[u].r<=r) return t[u].sum;包含就返回int mid=t[u].l+t[u].r>>1;不包含就递归到左右儿子int ans=0;if(l<=mid) ans+=find(u<<1,l,r);if(mid<r) ans+=find(u<<1|1,l,r);注意这里不是else，即使访问了左儿子，右儿子可能需要递归return ans;
}

这样我们发现，一次区间查询事实上访问了线段树上$O(\log n)$个节点，例如我们要查询区间$[2,8]$，具体来说是这样的：

其中黑色节点表示访问到的节点，红色的叶子节点表示实际要查询的区间。

现在我们来分析一下查询操作的时间复杂度。
对于所有与$[l,r]$有交的节点，显然它们一定是连通的，因为与$[l,r]$有交的一个节点的父亲也与$[l,r]$有交，而它们最终都会与根节点连通。

所以他们会形成一个线段树的一个导出连通图，这个图是一颗树。
显然所有可能被访问的节点都位与这棵树上，接下来我们具体分析一下哪些节点会被访问：

• 第一类节点：对于不被$[l,r]$完全包含的节点来说，这样的节点每层最多有$2$个，一个与$l$相交，另一个与$r$相交。因此这样的节点至多有约$O(2\log n)$个。我们认为它们全部被访问（事实也是如此）
  因为如果同一层有多余两个的节点与$l$或$r$相交，则必然有两个节点相交，但同一层节点显然无交。因此一层之中这样的节点最多两个。
• 第二类节点：对于被$[l,r]$完全包含的节点来说，$u$被访问到的充要条件是，$u$的父亲不被$[l,r]$完全包含。也就是说它必须是第一类节点的儿子，显然得到它的数量上界为$O(4\log n)$。
  但是注意到一个第一类节点至多有一个第二类儿子，否则它自身就是第二类节点，显然所以第二类被访问节点的数量至多有$O(2\log n)$个。

线段树的重要思想就是，把一次区间操作对应为线段树上$O(\log n)$个节点。

因此每次查询大约访问$O(4\log n)$个线段树节点，时间复杂度为$O(\log n)$。

实现

剩余的就是主函数部分，没什么好说的。

#include<iostream>
using namespace std;
const int N=5e5;
struct node{int l,r;int sum; 
}t[N<<2];
void build(int u,int l,int r) {t[u]={l,r,0};if(l==r) return ;int mid=l+r>>1;build(u<<1,l,mid);build(u<<1|1,mid+1,r);
}
void push_up(int u) {t[u].sum=t[u<<1].sum+t[u<<1|1].sum;
}
void push(int u,int p,int val) {if(t[u].l==t[u].r&&t[u].r==p) t[u].sum+=val;else {int mid=t[u].l+t[u].r>>1;if(p<=mid) push(u<<1,p,val);if(mid<p) push(u<<1|1,p,val);push_up(u);}
}
int find(int u,int l,int r) {if(l<=t[u].l&&t[u].r<=r) return t[u].sum;int mid=t[u].l+t[u].r>>1;int ans=0;if(l<=mid) ans+=find(u<<1,l,r);if(mid<r) ans+=find(u<<1|1,l,r);return ans;
}
int main() {int n,m;cin>>n>>m;build(1,1,n);for(int i=1,x;i<=n;i++) cin>>x,push(1,i,x);while(m--) {int op,x,y;cin>>op>>x>>y;if(op==1) push(1,x,y);if(op==2) cout<<find(1,x,y)<<endl;}
}

例题2

struct node{int l,r;long long sum,add; 
}t[N<<2];

下放标记（push_down）

具体来说，push_down(u)将$u$的懒标记下放给$u$的两个儿子。所以调用这个函数表示$u$有左右儿子。

void push_down(int u) {int l=u<<1,r=u<<1|1;下放懒标记：t[l].add+=t[u].add;t[r].add+=t[u].add;处理懒标记对区间和标记的影响：t[l].sum+=t[u].add*(t[l].r-t[l].l+1);t[r].sum+=t[u].add*(t[r].r-t[r].l+1);清空u的懒标记：t[u].add=0;
}

在push，find访问到$u$时，如果要访问$u$的儿子，就必须先下放懒标记。

void push(int u,int l,int r,long long val) {if(l<=t[u].l&&t[u].r<=r) t[u].sum+=val*(t[u].r-t[u].l+1),t[u].add+=val;else {push_down(u);下放懒标记int mid=t[u].l+t[u].r>>1;if(l<=mid) push(u<<1,l,r,val);if(mid<r) push(u<<1|1,l,r,val);push_up(u);上传标记}
}
long long find(int u,int l,int r) {if(l<=t[u].l&&t[u].r<=r) return t[u].sum;push_down(u);下放懒标记int mid=t[u].l+t[u].r>>1;long long ans=0;if(l<=mid) ans+=find(u<<1,l,r);if(mid<r) ans+=find(u<<1|1,l,r);find函数可以不需要push_up，因为push的时候push_up的作用是计算当前push操作对儿子的作用。这个作用没有在父亲处计算。（有时也无法在父亲处计算）而find函数对子节点唯一的影响是，可能会下放懒标记，但push_down的影响在之前计算过了。return ans;
}

实现

#include<iostream>
using namespace std;
const int N=1e5;
struct node{int l,r;long long sum,add; 
}t[N<<2];
void build(int u,int l,int r) {t[u]={l,r,0,0};if(l==r) return ;int mid=l+r>>1;build(u<<1,l,mid);build(u<<1|1,mid+1,r);
}
void push_up(int u) {t[u].sum=t[u<<1].sum+t[u<<1|1].sum;
}
void push_down(int u) {int l=u<<1,r=u<<1|1;t[l].add+=t[u].add;t[r].add+=t[u].add;t[l].sum+=t[u].add*(t[l].r-t[l].l+1);t[r].sum+=t[u].add*(t[r].r-t[r].l+1);t[u].add=0;
}
void push(int u,int l,int r,long long val) {if(l<=t[u].l&&t[u].r<=r) t[u].sum+=val*(t[u].r-t[u].l+1),t[u].add+=val;else {push_down(u);int mid=t[u].l+t[u].r>>1;if(l<=mid) push(u<<1,l,r,val);if(mid<r) push(u<<1|1,l,r,val);push_up(u);}
}
long long find(int u,int l,int r) {if(l<=t[u].l&&t[u].r<=r) return t[u].sum;push_down(u);int mid=t[u].l+t[u].r>>1;long long ans=0;if(l<=mid) ans+=find(u<<1,l,r);if(mid<r) ans+=find(u<<1|1,l,r);return ans;
}
int main() {int n,m;cin>>n>>m;build(1,1,n);for(long long i=1,x;i<=n;i++) cin>>x,push(1,i,i,x);while(m--) {int op,x,y;cin>>op>>x>>y;if(op==1) {long long k;cin>>k;push(1,x,y,k);}if(op==2) cout<<find(1,x,y)<<endl;}
}

例题3

struct node{int l,r;long long sum,add,mul; 
}t[N<<2];

乘法修改（set_mul）

如果要对节点进行一次乘法，懒标记的改动用set_mul函数实现：
$(mu{l}_u\times su{m}_u+ad{d}_u)\times mul=(mu{l}_u\times mul)\times sum+(ad{d}_u\times mul)$

$mu{l}_u\leftarrow mu{l}_u\times mul$
$ad{d}_u\leftarrow ad{d}_u\times mul$

void set_mul(int u,long long mul) {(t[u].add*=mul)%=M;(t[u].mul*=mul)%=M; (t[u].sum*=mul)%=M;
}

加法修改（set_add）

如果要对节点进行一次加法，懒标记的改动用set_add函数实现：

void set_add(int u,long long add) {(t[u].add+=add)%=M;(t[u].sum+=add*(t[u].r-t[u].l+1))%=M;注意加法操作对于sum的影响要乘以区间长度
}

下放标记（push_down）

标记下放相当于对子节点进行修改，注意先乘后加。

void push_down(int u) {set_mul(u<<1,t[u].mul);set_mul(u<<1|1,t[u].mul);set_add(u<<1,t[u].add);set_add(u<<1|1,t[u].add);t[u].mul=1;t[u].add=0;
}

这样的话，修改也有两个版本，一个是区间加，一个是区间乘法：

void pushadd(int u,int l,int r,long long add) {if(l<=t[u].l&&t[u].r<=r) set_add(u,add);else {push_down(u);int mid=t[u].l+t[u].r>>1;if(l<=mid) pushadd(u<<1,l,r,add);if(mid<r) pushadd(u<<1|1,l,r,add);push_up(u);}
}
void pushmul(int u,int l,int r,long long mul) {if(l<=t[u].l&&t[u].r<=r) set_mul(u,mul);else {push_down(u);int mid=t[u].l+t[u].r>>1;if(l<=mid) pushmul(u<<1,l,r,mul);if(mid<r) pushmul(u<<1|1,l,r,mul);push_up(u);}
}

实现

#include<iostream>
using namespace std;
const int N=1e5;
long long M; 
struct node{int l,r;long long sum,add,mul; 
}t[N<<2];
void build(int u,int l,int r) {t[u]={l,r,0,0,1};if(l==r) return ;int mid=l+r>>1;build(u<<1,l,mid);build(u<<1|1,mid+1,r);
}
void push_up(int u) {(t[u].sum=t[u<<1].sum+t[u<<1|1].sum)%=M;
}
void set_mul(int u,long long mul) {(t[u].add*=mul)%=M;(t[u].mul*=mul)%=M; (t[u].sum*=mul)%=M;
}
void set_add(int u,long long add) {(t[u].add+=add)%=M;(t[u].sum+=add*(t[u].r-t[u].l+1))%=M;
}
void push_down(int u) {set_mul(u<<1,t[u].mul);set_mul(u<<1|1,t[u].mul);set_add(u<<1,t[u].add);set_add(u<<1|1,t[u].add);t[u].mul=1;t[u].add=0;
}
void pushadd(int u,int l,int r,long long add) {if(l<=t[u].l&&t[u].r<=r) set_add(u,add);else {push_down(u);int mid=t[u].l+t[u].r>>1;if(l<=mid) pushadd(u<<1,l,r,add);if(mid<r) pushadd(u<<1|1,l,r,add);push_up(u);}
}
void pushmul(int u,int l,int r,long long mul) {if(l<=t[u].l&&t[u].r<=r) set_mul(u,mul);else {push_down(u);int mid=t[u].l+t[u].r>>1;if(l<=mid) pushmul(u<<1,l,r,mul);if(mid<r) pushmul(u<<1|1,l,r,mul);push_up(u);}
}
long long find(int u,int l,int r) {if(l<=t[u].l&&t[u].r<=r) return t[u].sum;push_down(u);int mid=t[u].l+t[u].r>>1;long long ans=0;if(l<=mid) ans+=find(u<<1,l,r);if(mid<r) ans+=find(u<<1|1,l,r);return ans%M;
}
int main() {int n,m;cin>>n>>m>>M;build(1,1,n);for(long long i=1,x;i<=n;i++) cin>>x,pushadd(1,i,i,x);while(m--) {int op,l,r;long long k;cin>>op>>l>>r;if(op==1) {cin>>k;pushmul(1,l,r,k%M);}if(op==2) {cin>>k;pushadd(1,l,r,k%M);}if(op==3) cout<<find(1,l,r)<<endl;} 
}

其他题目

P1198
P4588
P1471

权值线段树

通常的线段树是区间树，每个节点对应一段区间。

权值树维护的是值域。
权值线段树即值域线段树，每个节点对应一段值域连续段的信息。
可以认为，权值线段树是维护桶数组的区间线段树。

维护负数值域需要加上偏移，除此之外，写法上来说没有区别。

动态开点线段树

通常的线段树是堆式存储的，这样需要开辟$4N$的空间。事实上宽度为$N$的线段树至多有$2N-1$个节点，只需要开辟$2N$的空间。

更进一步来说，假设对于宽度为$T$的线段树进行$m$次修改操作，那么最多访问到其中的$O(m\log T)$个节点，因此空间只需要开到$O(m\log T)$即可。在$T$很大的时候（例如权值线段树）往往很有帮助。

动态开点权值线段树在空间计算上要尤其注意，防止空间超限。并且要注意$n,m,T$很可能不相等，即使在${\log }_2$中计算，也尽量不要混用。
还要注意，单点修改和区间修改会创建的节点数是不同的，对于宽度为$T$而言，单点修改会创建$\lceil {\log }_{2}T\rceil$个节点，而区间修改会创建$4\lceil {\log }_{2}T\rceil$个节点。

例题1

const int N=5e5;
struct node{int l,r,lc,rc;int sum; 
}t[N*30];

int tot;
int&lc(int u) {if(t[u].lc) return t[u].lc;t[++tot]={t[u].l,t[u].l+t[u].r>>1};return t[u].lc=tot;
}
int&rc(int u) {if(t[u].rc) return t[u].rc;t[++tot]={(t[u].l+t[u].r>>1)+1,t[u].r};return t[u].rc=tot;
}

t[++tot]={1,int(1e9)};

#include<iostream>
using namespace std;
const int N=5e5;
struct node{int l,r,lc,rc;int sum; 
}t[N*30];
这个空间事实上是超限的，但是由于洛谷特性只会计算动态内容，加上数据过水就跑过去了。
int tot;
int&lc(int u) {if(t[u].lc) return t[u].lc;t[++tot]={t[u].l,t[u].l+t[u].r>>1};return t[u].lc=tot;
}
int&rc(int u) {if(t[u].rc) return t[u].rc;t[++tot]={(t[u].l+t[u].r>>1)+1,t[u].r};return t[u].rc=tot;
}
void push_up(int u) {t[u].sum=t[t[u].lc].sum+t[t[u].rc].sum;注意这里如果没有左右儿子我们不希望创建，因此不能使用lc(u),rc(u)函数0节点的sum为0
}
void push(int u,int l,int r,int val) {if(l<=t[u].l&&t[u].r<=r) t[u].sum++;else {int mid=t[u].l+t[u].r>>1;if(l<=mid) push(lc(u),l,r,val);如果没有儿子，push需要创建儿子if(mid<r) push(rc(u),l,r,val);push_up(u);}
}
int find(int u,int l,int r) {if(l<=t[u].l&&t[u].r<=r) return t[u].sum;int mid=t[u].l+t[u].r>>1;int ans=0;if(l<=mid&&t[u].lc) ans+=find(lc(u),l,r);这里需要先检查有没有儿子，如果有儿子再递归检查有无儿子不能使用lc(u)函数，只能用t[u].lcif(mid<r&&t[u].rc) ans+=find(rc(u),l,r);return ans;
}
int a[N+5];
int main() {
// 	cout<<sizeof t/1e6;t[++tot]={1,int(1e9)};int n;cin>>n;for(int i=1;i<=n;i++) cin>>a[i];long long ans=0;for(int i=1;i<=n;i++) {if(a[i]!=1e9) 注意我们的find函数不接受l>r的参数，因此需要特判a[i]=1e9，或者建树的时候开大当然不加这个判断也跑过去了。（数据真水）ans+=find(1,a[i]+1,int(1e9));push(1,a[i],a[i],1);}cout<<ans;
}

标记永久化

通常的区间修改标记，通过在访问该节点时下放懒标记更新儿子节点来实现。永久标记没有下放懒标记的操作，它通过在递归查询计算出对儿子节点的影响来实现区间修改的效果。

并不是所有标记都可以永久化。

例题1

下放标记（push_up）

由于儿子节点的$sum$不再是它们真实值，而是它们去除了被祖先节点永久化后的加法标记造成的影响之后的值，因此在push_up的时候要把本层的加法标记算上。

我们维护sum为考虑子树内全部标记的区间和。

void push_up(int u) {t[u].sum=t[u<<1].sum+t[u<<1|1].sum+t[u].add*(t[u].r-t[u].l+1);
}

查询（find）

查询要注意，在查询时计算本层永久标记对答案的影响。

long long find(int u,int l,int r) {if(l<=t[u].l&&t[u].r<=r) return t[u].sum;int mid=t[u].l+t[u].r>>1;long long ans=0;if(l<=mid) ans+=find(u<<1,l,r);if(mid<r) ans+=find(u<<1|1,l,r);return ans+t[u].add*(min(t[u].r,r)-max(t[u].l,l)+1);这里加上了t[u].add*(u对应的区间与[l,r]相交的大小)，计算了永久标记对答案的影响。
}

实现

值得一提的是，这里使用long long是不严谨的，因为题设并没有保证这种做法不会爆long long。但是它过了。
#include<iostream>
using namespace std;
const int N=1e5;
struct node {int l,r;long long sum,add;
}t[N<<2];
void build(int u,int l,int r) {t[u]={l,r};if(l==r) return ;int mid=l+r>>1;build(u<<1,l,mid);build(u<<1|1,mid+1,r);
}
void push_up(int u) {t[u].sum=t[u<<1].sum+t[u<<1|1].sum+t[u].add*(t[u].r-t[u].l+1);
}
void push(int u,int l,int r,long long add) {if(l<=t[u].l&&t[u].r<=r) t[u].add+=add,t[u].sum+=add*(t[u].r-t[u].l+1);else {int mid=t[u].l+t[u].r>>1;if(l<=mid) push(u<<1,l,r,add);if(mid<r) push(u<<1|1,l,r,add);push_up(u);}
}
long long find(int u,int l,int r) {if(l<=t[u].l&&t[u].r<=r) return t[u].sum;int mid=t[u].l+t[u].r>>1;long long ans=0;if(l<=mid) ans+=find(u<<1,l,r);if(mid<r) ans+=find(u<<1|1,l,r);return ans+t[u].add*(min(t[u].r,r)-max(t[u].l,l)+1);
}
int main() {int n,m;cin>>n>>m;build(1,1,n);for(long long i=1,x;i<=n;i++) cin>>x,push(1,i,i,x);while(m--) {int op,l,r;long long k;cin>>op>>l>>r;if(op==1) {cin>>k;push(1,l,r,k);}if(op==2) cout<<find(1,l,r)<<endl;}
}

常见可永久化标记

标记永久化局限非常大，一般只在不得不使用或使用大幅减少码量时使用。

常见有以下标记单独出现时可以永久化：

• 区间加标记
• 区间乘标记
  区间加乘标记不可永久化
• 扫描线段树标记（线段覆盖标记）
• 李超线段树标记
• 可持久化线段树标记必须永久化

后记

下篇