线段树 & 树状数组

线段树

常用于维护区间值

代码

和题解有很大差异，但是过了就好

void Pushup(int x) {
	s[x]=(s[x<<1]+s[x<<1|1]);
}
void Pushdown(int x,int l,int r) {
	s[x]=(s[x]+ad[x]*(r-l+1));
	if(l!=r) ad[x<<1]=(ad[x<<1]+ad[x]);
	if(l!=r) ad[x<<1|1]=(ad[x<<1|1]+ad[x]);
	ad[x]=0;
}
void Build(int x,int l,int r) {
	if(l==r) {
		s[x]=a[l];
		return;
	}
	int mid=(l+r)>>1;
	Build(x<<1,l,mid);
	Build(x<<1|1,mid+1,r);
	Pushup(x);
}
void Plus(int x,int l,int r,int k,int L,int R) {
	Pushdown(x,l,r);
	if(l>=L&&r<=R) {
		if(l!=r) ad[x<<1]=(ad[x<<1]+k);
		if(l!=r) ad[x<<1|1]=(ad[x<<1|1]+k);
		s[x]=(s[x]+(r-l+1)*k);
		return;
	}	
	int mid=(l+r)>>1;
	Pushdown(x<<1,l,mid);
	Pushdown(x<<1|1,mid+1,r);	//注意这两句
	if(L<=mid) Plus(x<<1,l,mid,k,L,R);
	if(R>mid) Plus(x<<1|1,mid+1,r,k,L,R);
	Pushup(x);
}
long long Quary(int x,int l,int r,int L,int R) {
	Pushdown(x,l,r);
	if(l>=L&&r<=R) return s[x];
	long long ans=0;
	int mid=(l+r)>>1;
	if(L<=mid) ans=(ans+Quary(x<<1,l,mid,L,R));
	if(R>mid) ans=(ans+Quary(x<<1|1,mid+1,r,L,R));
	return ans;
}

实现细节

线段树开4倍大小的原因是，一些数（如5）可能使得层数多一层

Pushup的时候俩儿子的懒标记必须传干净

Pushdown的时候注意不要让叶子节点访问子节点，不然会RE

Pushdown用法总结：

1、访问到一个节点时，啥也不干，先Pushdown消除懒标记，使得后面的分析更容易；

2、Plus函数在访问完两个儿子后，要Pushup使得x数值正确，本来两儿子Add的Pushdown可以使得懒标记消掉，但是会有儿子进不了Add，因此需要在外面Pushdown一次；

3、Pushup不会对懒标记进行操作，故Pushup前先Pushdown两个儿子保证数值正确；

代码调试

对一个区间反复加和往往能发现问题（如[1,2]，[1,1]，[2,2]，[1,3]，[2,3]……）

当然，如果能背版是最好的

区间除法

转换成减法 未解决

区间开方

link

区间gcd

区间第一个值小于k的位置

区间最大子段和

维护区间和，最大前缀和，最大后缀和，最大子段和即可

例：小白逛公园

区间限长最大子段和

区间历史版本和

题目链接

维护从开始到当前时刻的$[l,r]$区间和的和，即求${\displaystyle \sum _{ver=1}^m{S}_{ver}[l\sim r]}$

一种思路是在后一个加标记遇到前一个加标记时，下推前一个加标记统计贡献

发现这种方法意味着加标记不可合并，会退化成$O(n^2)$（相当于加标记只能在叶子消除）

进一步思考发现：并不是不能合并，考虑前一个标记存在时的历史和：

$S=(s[x]+ad[x]\ast le{n}_{seq})\ast le{n}_{time}=s[x]\ast le{n}_{time}+ad[x]\ast le{n}_{time}\ast le{n}_{seq}$

这时$ad[x]\ast le{n}_{time}$与后续时间无关（因为$ad[x]$被更新了），又与区间长无关，可以作为标记下传

因此另开一个标记维护即可

大数比较

对于${10}^5$位的数的比较，可以用线段树上二分来做——在结点上挂哈希值，不同就进儿子继续比较，时间复杂度$O(\log n)$

例题：The Classic Problem 可持久化即可

扫描线

用于解决二维数点问题

模型：对于

线段树实现

设$s[x]$为$[l,r]$的总长度，$fac[x]$为$[l,r]$的实际覆盖长度,$tag[x]$为覆盖次数懒标记，$tag[x]$不为$0$时用$s[x]$更新$fac[fa[x]]$，否则用$fac[x]$

实现时发现$tag[x]$是难以维护的，因为$tag[x]$为$0$时不意味着儿子为$0$，而儿子的覆盖状态是离散的，无法获取

思考发现不同于正常线段树，$tag[x]$是不需要上传或下传的；当$tag[x]=1$时，$[l,r]$每个点覆盖次数$ \ge 1$，\mathrm{直}\mathrm{接}\mathrm{取}$s[x]$\mathrm{即}\mathrm{可}，\mathrm{当}$tag[x]=0$\mathrm{时}，\mathrm{覆}\mathrm{盖}\mathrm{状}\mathrm{态}\mathrm{一}\mathrm{定}\mathrm{是}\mathrm{若}\mathrm{干}\mathrm{个}\mathrm{区}\mathrm{间}，\mathrm{而}\mathrm{子}\mathrm{树}\mathrm{内}\mathrm{的}\mathrm{节}\mathrm{点}\mathrm{可}\mathrm{以}\mathrm{完}\mathrm{全}\mathrm{表}\mathrm{示}\mathrm{出}\mathrm{这}\mathrm{些}\mathrm{区}\mathrm{间}，\mathrm{这}\mathrm{些}\mathrm{表}\mathrm{示}\mathrm{区}\mathrm{间}\mathrm{的}\mathrm{节}\mathrm{点}$tag[]$均 $\ge 1$，说明它们的$s[]$在前面下放$tag[]$时已经统计上来，存在$fac[x]$中了，直接取$fac[x]$即可

例题

P1502 窗口的星星

直接考虑矩形的价值不可行

正难则反，考虑每个点的贡献，发现每个点对一个矩形内的点有贡献，贡献转移至矩形，扫描线

李超线段树

树状数组（BIT）

参考自bestsort的博文

定义

树状数组本质上为线段树的优化，与线段树相比，它的优点在于代码简洁，时间效率高（线段树固定是$O(logn)$，而树状数组最坏为$O(logn)$），但是遇到一些非常规操作，树状数组就没有那么灵活

以下是各路收集的优质理解：

线段树的变形

在用线段树求前缀和时，发现访问的节点均为左节点，大量节点弃置不用，造成时间和空间的浪费

如图，灰色节点永远用不上

于是对线段树进行改进，丢掉无用点，发现剩下的节点刚好就能放进原数组里，于是原数组就被改造为树状数组

基于二进制的高效访问

空间已经优化完了，但如果还是像线段树一样从根向下一层一层跑，那就优化了个寂寞

于是有人发现了树状数组的访问规律

lowbit(x):取出x二进制位中最低位的1（注意取出的是1<<(i-1)不是位数i）

发现在查询时，只要不断丢掉最低位的1，就可以访问到全部前i个元素

而在单点修改时也类似，只要不断加上最低位的1，就可以完成管辖元素i的所有节点的更新

下图更清晰

另一种理解：区间求和

观察树状数组，发现对于节点i，其实管辖的是右端点为i，长度为lowbit(i)的区间，通过i-=lowbit(i)，可以快速跳往前一个区间，达到不重不漏地访问前i个元素，易知跳转操作次数由i的二进制表示中的1的个数决定，这就是树状数组的时间复杂度最坏为$O(logn)$的原因

这种理解在分析二维树状数组中会很方便

单点修改，区间查询

如上文

这里求lowbit(x)用了一种基于机器编码的方法，具体证明见bestsort原文

int n,c[MAXN];	//长度为n的树状数组
int lb(int x) {return x&-x;}
void Add(int x,int k) {
	for(int i=x;i<=n;i+=lb(x))
		c[i]+=k;
}
int Quary(int x) {
	int ans=0;
	for(int i=x;i;i-=lb(x))
		ans+=c[i];
	return ans;
}

Add(x,k);	//给元素x加上k
Quary(y)-Quary(x-1);	//[x,y]求和

区间修改，单点查询

考虑利用差分数组，这样前i个数的和就是元素i，而区改也能快速实现

//前面一样
Add(x,k); Add(y+1,-k);	//[x,y]加k
Quary(x);	//求元素x

区间修改，区间查询

考虑区改单查的变形

前x个元素的和为（d[]为差分数组）

$$\sum _{i=1}^{x}a[i]=\sum _{i=1}^x\sum _{j=1}^{i}d[j]=\sum _{i=1}^x(x-i+1)\ast d[i]$$

$$=(x+1)\ast \sum _{i=1}^{x}d[i]-\sum _{i=1}^{x}i\ast d[i]$$

记录两个数组 $d[i]$ 和 $s[i]=i\ast d[i]$ 即可

int n,d[MAXN],s[MAXN];
int lb(int x) {return x&-x;}
void Add(int x,int k) {
	for(int i=x;i<=n;i+=lb(x))
		d[i]+=k,s[i]+=k*x;
}
int Quary(int x) {
	int sumd=0,sums=0;
	for(int i=x;i;i-=lb(x))
		sumd+=d[i],sums+=s[i];
	return (x+1)*sumd-sums;
}

Add(x,k); Add(y+1,-k);	//[x,y]加k
Quary(y)-Quary(x-1);	//[x,y]求和

树状数组二分

和线段树一样，树状数组也可以二分

上面提到的一种定义$c[i]$的方法：右端点为i，长度为lowbit(i)的区间

由于lowbit(i)为$2^k$，考虑类似倍增的思路

令$pos=0$，$s=0$，不断尝试对$pos$加上$2^{20},2^{19},...,2^0$，此时，$s$的增量为$c[pos+2^k]$（因为最低位是刚加上去的$k$），如果$s+c[pos+2^k]<=goal$，则加上这一位

二维树状数组

类比一维树状数组，c[x]表示右端点为x，长度为lowbit(x)的区间，则c[x][y]表示右下角坐标为(x,y)，长lowbit(x)，宽lowbit(y)的矩阵，类推转移即可

（懒得写了，现场推吧）

模型：求区间元素种类数

[P1972] HH的项链

树状数组可以快速地统计前缀和，但是遇到相同元素就会重复统计种类

由于在[l,r]中，第i种颜色只能在最后一个该颜色删除后才会消失，所以只需维护每种颜色最后出现的位置即可

01树状数组存储，st数组记录每种元素最后出现位置，若有相同元素进入，则删掉该位的1（没有贡献），更新st[]

权值线段树 & 权值树状数组

在统计个数问题上（三维偏序）有优势

求区间第k小值

权值线段树+二分即可，时间复杂度为$O(nlogn)$

这是主席树的底层原理之一

动态开点线段树

细节

一般开到 $n\ast 50$ 就差不多了

注意与动态开点线段树有关的题目，自己分析复杂度正确时TLE，有可能是炸数组了（普通线段树是RE）

线段树合并

对于一棵树，如果每个点只有$O(1)$的信息，要求快速求出一系列点（链或子树）的信息，可以对每个点开一棵线段树，用线段树合并维护

思路：类似于主席树，可以想到链上的该问题主席树可以维护，而到了树上，就考虑线段树合并

有两种写法，时间复杂度都是$O(nlogn)$

写法1：一次性

对于树$v\to$树$ u$\mathrm{的}\mathrm{合}\mathrm{并}，\mathrm{每}\mathrm{次}\mathrm{直}\mathrm{接}\mathrm{把}$v$\mathrm{的}\mathrm{结}\mathrm{点}\mathrm{作}\mathrm{为}$u$\mathrm{的}\mathrm{儿}\mathrm{子}，\mathrm{递}\mathrm{归}\mathrm{处}\mathrm{理}，\mathrm{这}\mathrm{样}\mathrm{会}\mathrm{导}\mathrm{致}$u$\mathrm{进}\mathrm{行}\mathrm{下}\mathrm{一}\mathrm{次}\mathrm{合}\mathrm{并}\mathrm{时}$v$\mathrm{的}\mathrm{结}\mathrm{构}\mathrm{会}\mathrm{被}\mathrm{破}\mathrm{坏}，\mathrm{因}\mathrm{此}\mathrm{必}\mathrm{须}\mathrm{在}$DFS$合并后立刻访问

空间复杂度大概为$O(n\ast 20)$

细节

线段树合并时，如果这么写：

	int mid=(l+r)>>1;
	if(!lc[now]&&lc[pre]) lc[now]=lc[pre];
	if(lc[now]&&lc[pre]) Merge(lc[now],lc[pre],l,mid);
	if(!rc[now]&&rc[pre]) rc[now]=rc[pre];
	if(rc[now]&&rc[pre]) Merge(rc[now],rc[pre],mid+1,r)

那么在进入第一个if后，lc[now]获得值，进入第二个if，导致出错，因此要用else分隔

写法2：可持久化

先和写法1一致，到并下一棵树时，如果有点值变化的点是$v$的结点，新建一个属于$x$的结点，把$v$的结点的性质拷贝过去另外做

空间复杂度大概为$O(n\ast 60)$

复杂度分析

待办

应用

P4556 [Vani有约会]雨天的尾巴 /【模板】线段树合并

#3628. 「2021 集训队互测」树上的孤独

补充

对于支持线段树合并的题，都支持树链剖分（因为链和子树都在$DFS$序上连续），大概做法为剖询问变成$O(logn)$个，在$DFS$序数组上差分，然后扫描线/主席树

前者时间较优，后者空间较优

主席树

主席树即为可持久化线段树，思路就是对每一个历史版本都开一棵线段树，但是这样时间复杂度会很高。

由前面线段树合并可知，当点数较少时，用动态开点线段树比较优，则对于版本$i-1$到$i$的变化，如果单点变化，会有大量的节点状态不变，因此这两棵树可以共用这些节点的值，而变化的单点动态开点即可

求区间第k小值

沿用之前历史版本的思路，对每一个$[1,i]$求一棵权值线段树，求答案时把第$r$棵和第$l-1$棵一起放进去跑线段树二分即可

可持久化数组

实际上为主席树的弱化版：对于单点修改的数组建立主席树，实际上就是只有叶子挂东西的线段树

细节

可持久化trie中叶子节点的更新是s[x]=s[pre]+1，不是s[x]++——这样写会丢失前面相同的值

P3293 [SCOI2016]美味

思考发现没有数据结构可以同时高效维护异或和加，考虑分位

我们从高位到低位考虑：要想取最大值，就要使高位尽量为$1$，问题转化为能否存在$[l,r]$中的数$a_k$，使得当前第$i$位有$bi{t}_i(b)\oplus bi{t}_i(a_k+x)=1$，假设$bi{t}_i(b)=0$，不难发现这样的$a_k+x$应在$[...100000...]\sim [...111111...]$之间（$1$为第$i$位），找到这两个边界，记作$l^{\prime },r^{\prime }$，即为查询$[l,r]$中有没有$[l^{\prime }-x,r^{\prime }-x]$中的数，对$a[]$建立权值主席树即可维护

时间复杂度$O(n{\log }^{2}n)$，注意位运算玄学优先级

树套树

树套树实际上是一种思想——线段树的结点并不只能挂值，可以挂线段（李超树），线段树，平衡树，堆等等

一个经典问题就是二维线段树——对行开一个线段树，结点上挂统计处理$[l,r]$这几行的信息的树

有时候第二维不一定是$y$坐标，也可以是时间维度，权值等

由于线段树只有$O(\log n)$层，在结点上开维护该区间的点的平衡树，空间复杂度为$O(n\log n)$（?）（动态开点线段树为$O(n{\log }^{2}n)$）

基于满二叉树的数据结构

zkw线段树

非递归版线段树，具有优秀的常数

考虑将一棵线段树底层结点补成$2^k$个，此时，底层结点，父亲，两个儿子的下标都可以快速获取

所以这棵线段树可以从下往上跑（普通线段树都是从上往下）

区间修改

由于从下往上跑，区间标记不好下传，考虑标记永久化

在往上跑时，如果自己的兄弟也在区间内，给兄弟也打上标记

区间查询

由于标记永久化，所有的询问都得跑到根，以获取全部标记（类似李超树）

猫树

满二叉树维护无修改区间查询，预处理复杂度$O(n\log n)$，单次询问复杂度$O(1)$

先补全数组至$2^k$，树分为$O(\log n)$层，每层的结点$i$记录$[i,mid]$或$[mid+1,r]$的区间值（取决于在$mid$的左边还是右边）

询问时跳到$l,r$被$mid$分隔的那一层，查询这两个点的值$[l,mid],[mid+1,r]$即可，而层数是可以快速获取的—— $dep[LCA(l,r)]=Lo{g}_2[pos[l]]-Lo{g}_2[pos[l]xorpos[r]]$

猫树和zkw线段树底层思想差不多，都是基于快速访问下标来优化时间，但猫树和普通线段树结构又有区别——猫树空间是$O(n\log n)$的，因为每一层每个位置都要维护值，而线段树空间是$O(n)$的