线段树基础
书接上文树状数组，区间修改与区间查询用线段树实现
线段树的拓展性较强，一般被当做处理区间的工具，所以熟练的掌握线段树尤为重要
线段树的结构分析
线段树的本质是一颗二叉树，这意味着我们开数组时往往需要4倍n（原数组长）的空间。
通过上图可以发现，每个线段树的节点都有左右端点（毕竟是线段嘛），节点存放的值就是在这个区间内线段树需要维护的值。
加法线段树的维护与查询
线段树的修改
假设我们要令区间 （x,y）增加 ，从树的根开始找，很明显根的左右节点为（1,n） ,进行递归查询，定义每次查找到的节点为p,区间为(l,r)，mid=(l+r)/2，根据二叉树方式递归
现在就会出现三种情况
1、区间(x,y)完全包括区间（l,r），此时就可以直接令当前节点增加k*(r-l+1)
2、(x,y)与(l,mid)有交集，递归左儿子
3、(x,y)，与(mid+1,r)有交集，递归右儿子
这是线段树维护和查询的基本框架，
是不是觉得很简单，但我们还举回上面(1,4)区间的例子
假设我更新了（1,3）区间，现在请你按照上述方式推一下，会发现只有(1,2)和(3,3)节点被更新了
但如果此时我查询区间(2,4)，我搜索到节点(2,2)时，理论上它应该被更新，但实际上并没有
针对这样的漏洞，你会怎么解决？
难道每次都把所有包括的节点都更新吗，显然那样线段树根本起不到优化作用(甚至>暴力)
所以lazytag懒标记就显得尤为关键，懒标记的思想就是增加一个线段树维护的值
每次修改时对于当前节点的懒标记增加k，在修改与查询的时候，我们在递归左右儿子的时候不断下传懒标记给儿子，这样既不会增加时间，也能解决上述问题
要注意的是懒标记下传时当前节点懒标记要清0(不然就重复累加了)
线段树的查询
查询函数的基本逻辑与修改一样，返回左右儿子之和作为答案，此时也需要下传懒标记
代码及注释
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int MAXN=1e5+10;
unsigned ll n,m,a[MAXN],ans[MAXN*4],la[MAXN*4];
inline ll ls(ll x)
{
return x*2;
}
inline ll rs(ll x)
{
return x*2+1;
}
//求子节点
void cr()
{
scanf("%lld%lld",&n,&m);
}
inline void push_up(ll p)//求和
{
ans[p]=ans[ls(p)]+ans[rs(p)];
}
void build(ll p,ll l,ll r)//按原数据建树
{
la[p]=0;
if(l==r){ans[p]=a[l];return ;}
ll mid=(l+r)>>1;
build(ls(p),l,mid);
build(rs(p),mid+1,r);//分治思想
push_up(p);//回溯时求和
}
inline void f(ll p,ll l,ll r,ll k)
{
la[p]=la[p]+k;
ans[p]=ans[p]+k*(r-l+1);
}
inline void push_down(ll p,ll l,ll r)
{
ll mid=(l+r)>>1;
f(ls(p),l,mid,la[p]);//将懒标记加入子节点
f(rs(p),mid+1,r,la[p]);
la[p]=0;
//懒标记归零
}
inline void update(ll nl,ll nr,ll l,ll r,ll p,ll k)
{
if(nl<=l&&r<=nr)
{
ans[p]+=k*(r-l+1);
la[p]+=k;
return ;//要求区间完全包裹被查询区间就直接更新
}
push_down(p,l,r);//下传懒标记
ll mid=(l+r)>>1;
if(nl<=mid)update(nl,nr,l,mid,ls(p),k);
if(nr>mid) update(nl,nr,mid+1,r,rs(p),k);
//要求区间与左右任意区间有重合就更新
push_up(p);//求和
}
ll query(ll q_x,ll q_y,ll l,ll r,ll p)
{
ll res=0;
if(q_x<=l&&r<=q_y)return ans[p];//要求区间完全包裹被查询区间
ll mid=(l+r)>>1;
push_down(p,l,r);//下传懒标记
if(q_x<=mid)res+=query(q_x,q_y,l,mid,ls(p));
if(q_y>mid) res+=query(q_x,q_y,mid+1,r,rs(p));//左右儿子
return res;
}
int main()
{
ll a1,x1,y1,z1;
cr();
build(1,1,n);
while(m--)
{
scanf("%lld",&a1);
if(a1==0){
scanf("%lld%lld%lld",&x1,&y1,&z1);
update(x1,y1,1,n,1,z1);//更改区间x1,y1 查询区间 1~n 根节点1 增加z1
}
if(a1==1) {
scanf("%lld%lld",&x1,&y1);
printf("%lld\n",query(x1,y1,1,n,1));
}
}
return 0;
}加乘线段树的维护
加乘优先级
如果这个线段树只有乘法，那么直接将lazytag的加法变成乘，然后ans[p]*=k就好了。但是，如果我们是又加又乘，那就不一样了。
此时线段树的维护有两种操作：令区间(x,y)+k 、 令区间(x,y)*k
那么引申出一个问题，lazytag先加再乘还是先乘再加
而所谓先乘后加就是在做乘法的时候把加法标记也乘上这个数，在后面做加法的时候直接加
简单举个例子
考虑1~3的线段树，现将1~3加2，再将1~3乘上3，最后让1~3加4
求1~3的和
自己纸笔根据先加再乘和先乘再加运算一下
答案应该是
sum=(a[1]+2)*3+(a[2]+2)*3+(a[3]+2)*3;先加再乘
sum=(a[1]+2+4)*3+(a[2]+2+4)*3+(a[3]+2+4)*3;
=(a[1]+2)*3+4*3+(a[2]+2)*3+4*3+(a[3]+2)*3+4*3;显然两者不等价
而先乘后加
sum=(a[1]*3+2*3+4)+(a[2]*3+2*3+4)+(a[3]*3+2*3+4);是正确的
所以我们使用先乘再加
push_down逻辑结构
此时我们需要两个lazytag，mlz和add，我们可以写一个结构体将lazytag和ans数组合并。
定义结构体数组tree,分析两个lazytag的处理方式
mlz很简单，pushdown时直接乘父亲的mlz就可以了
而add，我们需要的add*父亲的mlz再加上父亲的add
这就是push_down 函数的逻辑结构
代码及注释
我们需要分别写出维护乘和加的函数，两个函数的逻辑与求和线段树差别不大，根据代码注释自行理解即可
tips：乘法用longlong哦
代码对应题目洛谷P3373
#include<bits/stdc++.h>
using namespace std;
int mod;
long long a[100010];
struct tree{
long long v,mlz,add;//和，乘法lazytag，加法lazytag
}tr[400040];
void build(int root,int l,int r){//建树
tr[root].mlz=1;//乘法应初始化为1
tr[root].add=0;
if(l==r) tr[root].v=a[l];
else{
int mid=(l+r)>>1;
build(root*2,l,mid);
build(root*2+1,mid+1,r);
tr[root].v=tr[root*2].v+tr[root*2+1].v;
}
tr[root].v%=mod;
}
void pushdown(int root,int l,int r){
int mid=(l+r)>>1;
//根据我们规定的优先度，儿子的值=此刻儿子的值*爸爸的乘法lazytag+儿子的区间长度*爸爸的加法lazytag
tr[root*2].v=(tr[root*2].v*tr[root].mlz+tr[root].add*(mid-l+1))%mod;
tr[root*2+1].v=(tr[root*2+1].v*tr[root].mlz+tr[root].add*(r-mid))%mod;
tr[root*2].mlz=(tr[root*2].mlz*tr[root].mlz)%mod;
tr[root*2+1].mlz=(tr[root*2+1].mlz*tr[root].mlz)%mod;
tr[root*2].add=(tr[root*2].add*tr[root].mlz+tr[root].add)%mod;
tr[root*2+1].add=(tr[root*2+1].add*tr[root].mlz+tr[root].add)%mod;
tr[root].mlz=1;
tr[root].add=0;
}
void cheng(int root,int nl,int nr,int l,int r,long long k){
if(r<nl||nr<l){
return ;
}//越界返回
if(l<=nl&&nr<=r){
tr[root].v=(tr[root].v*k)%mod;
tr[root].mlz=(tr[root].mlz*k)%mod;
tr[root].add=(tr[root].add*k)%mod;
return ;
}//乘法时也要维护加法lazytag
pushdown(root,nl,nr);//传递lazytag
int mid=(nl+nr)>>1;
cheng(root*2,nl,mid,l,r,k);
cheng(root*2+1,mid+1,nr,l,r,k);
tr[root].v=(tr[root*2].v+tr[root*2+1].v)%mod;
}
void jia(int root,int nl,int nr,int l,int r,long long k){
if(r<nl||nr<l){
return ;
}//越界
if(l<=nl&&nr<=r){
tr[root].add=(tr[root].add+k)%mod;
tr[root].v=(tr[root].v+k*(nr-nl+1))%mod;
return ;
}//加法不变
pushdown(root,nl,nr);
int mid=(nl+nr)>>1;
jia(root*2,nl,mid,l,r,k);
jia(root*2+1,mid+1,nr,l,r,k);
tr[root].v=(tr[root*2].v+tr[root*2+1].v)%mod;
}
long long query(int root,int nl,int nr,int l,int r){
if(r<nl||nr<l){
return 0;
}
if(l<=nl&&nr<=r){
return tr[root].v;
}
pushdown(root,nl,nr);
int mid=(nl+nr)>>1;
return (query(root*2,nl,mid,l,r)+query(root*2+1,mid+1,nr,l,r))%mod;
}
int main(){
int n,m;
scanf("%d%d%d",&n,&m,&mod);
for(int i=1;i<=n;i++){
scanf("%lld",&a[i]);
}
build(1,1,n);
while(m--){
int sb;
scanf("%d",&sb);
if(sb==1){
int x,y;
long long k;
scanf("%d%d%lld",&x,&y,&k);
cheng(1,1,n,x,y,k);
}
if(sb==2){
int x,y;
long long k;
scanf("%d%d%lld",&x,&y,&k);
jia(1,1,n,x,y,k);
}
if(sb==3){
int x,y;
scanf("%d%d",&x,&y);
printf("%lld\n",query(1,1,n,x,y));
}
}
}
浙公网安备 33010602011771号