线段树--线段树【模板1】P3372

题目描述

如题，已知一个数列，你需要进行下面两种操作：

1.将某区间每一个数加上$x$

2.求出某区间每一个数的和

输入格式

第一行包含两个整数N、M，分别表示该数列数字的个数和操作的总个数。

第二行包含N个用空格分隔的整数，其中第i个数字表示数列第i项的初始值。

接下来M行每行包含3或4个整数，表示一个操作，具体如下：

操作1： 格式：1 $x$ $y$ $k$ 含义：将区间$[x,y]$内每个数加上$k$

操作2： 格式：2 $x$ $y$ 含义：输出区间$[x,y]$内每个数的和

输出格式

输出包含若干行整数，即为所有操作2的结果。

 

1.构建树

更新$a_i$的值时，需要对所有包含$i$这个位置的结点的值重新计算。

对于线段树中的每一个非叶子节点$[a,b]$，它的左儿子表示的区间为$[a,(a+b)/2]$，右儿子表示的区间为$[(a+b)/2+1,b]$。我们就可以得出节点i的权值=她的左儿子权值+她的右儿子权值。一颗二叉树，她的左儿子和右儿子编号分别是她*2和她*2+1

 inline void add(int x, int l, int r, ll y)
 {
     c[x] += (r - l + ) * y;
     lazy[x] += y;
 }
 inline void pushup(int x)
 {
     c[x] = c[x*] + c[x*+];
 }
 inline void pushdown(int x, int l, int r)
 {
     add(x*, l, (l+r)/, lazy[x]);
     add(x*+, (l+r)/ + , r, lazy[x]);
     lazy[x] = ;
 }
 inline void build(int x, int l, int r)
 {
     if(l == r)
     return c[x] = a[l], void();
     build(x*, l, (l+r)/);
     build(x*+, (l+r)/ + , r);
     pushup(x);
 }

2.区间修改

1、如果这个区间被完全包括在目标区间里面，直接修改整个区间

2、如果这个区间的左儿子和目标区间有交集，那么修改左儿子

3、如果这个区间的右儿子和目标区间有交集，那么修改右儿子

 inline void revise(int x, int l, int r, int l1, int r1, ll y){
     if(l1 <= l && r <= r1)
         return add(x, l, r, y);
     if(lazy[x])
         pushdown(x, l, r);
     if(l1 <= (l+r)/)
         revise(x*, l, (l+r)/, l1, r1, y);
     if(r1 > (l+r)/)
         revise(x*+, (l+r)/ + , r, l1, r1, y);
     pushup(x);
 }

3.区间查询

1、如果这个区间被完全包括在目标区间里面，直接返回这个区间的值

2、如果这个区间的左儿子和目标区间有交集，那么搜索左儿子

3、如果这个区间的右儿子和目标区间有交集，那么搜索右儿子

 inline ll query(int x, int l, int r, int l1, int r1){
     if(l1 <= l && r <= r1)
         return c[x];
     if(lazy[x])
         pushdown(x, l, r);
     ll sum = ;
     if(l1 <= (l+r)/)
         sum += query(x*, l, (l+r)/, l1, r1);
     if(r1 > (l+r)/)
         sum += query(x*+, (l+r)/ + , r, l1, r1);
     return sum;
 }

这道题的完整代码：

 #include <algorithm>
 #include <cmath>
 #include <cstdio>
 #include <iostream>
 #include <cstring>
 #define ll long long
 using namespace std;
 const int N = ;
 int n, m, l, r, ans;
 ll k, a[N], c[N], lazy[N];
 inline void add(int x, int l, int r, ll y)
 {
     c[x] += (r - l + ) * y;
     lazy[x] += y;
 }
 inline void pushup(int x)
 {
     c[x] = c[x*] + c[x*+];
 }
 inline void pushdown(int x, int l, int r)
 {
     add(x*, l, (l+r)/, lazy[x]);
     add(x*+, (l+r)/ + , r, lazy[x]);
     lazy[x] = ;
 }
 inline void build(int x, int l, int r)
 {
     if(l == r)
     return c[x] = a[l], void();
     build(x*, l, (l+r)/);
     build(x*+, (l+r)/ + , r);
     pushup(x);
 }
 inline ll query(int x, int l, int r, int l1, int r1){
     if(l1 <= l && r <= r1)
         return c[x];
     if(lazy[x])
         pushdown(x, l, r);
     ll sum = ;
     if(l1 <= (l+r)/)
         sum += query(x*, l, (l+r)/, l1, r1);
     if(r1 > (l+r)/)
         sum += query(x*+, (l+r)/ + , r, l1, r1);
     return sum;
 }
 inline void revise(int x, int l, int r, int l1, int r1, ll y){
     if(l1 <= l && r <= r1)
         return add(x, l, r, y);
     if(lazy[x])
         pushdown(x, l, r);
     if(l1 <= (l+r)/)
         revise(x*, l, (l+r)/, l1, r1, y);
     if(r1 > (l+r)/)
         revise(x*+, (l+r)/ + , r, l1, r1, y);
     pushup(x);
 }

 int main(){
     scanf("%d %d", &n, &m);
     for (int i = ;i <= n;i++)
         scanf("%lld", &a[i]);
     build(, , n);
     for (int i = ;i <= m;i++){
         scanf("%d %d %d", &ans, &l, &r);
         if(ans & )
             scanf("%lld", &k), revise(, , n, l, r, k);
         else
             printf("%lld\n", query(, , n, l, r));
     }
     return ;
 }

*接下来附上几个基本代码：

一、区间最值

1.单点替换：

 const int M=;
 LL a[M];
 LL MAX[M<<];
 #define lson l,m,rt<<1
 #define rson m+1,r,rt<<1|1
 void update(int rt){
     MAX[rt]=max(MAX[rt<<],MAX[rt<<|]);
 }
 void build(int l,int r,int rt){
     if (l==r) {
         MAX[rt]=a[l];
         return;
     }
     int m=(l+r)>>;
     build(lson);
     build(rson);
     update(rt);
 }
 void modify(int l,int r,int rt,int p,int v){
     if (l==r) {
         MAX[rt]=v;
         return;
     }
     int m=(l+r)>>;
     if (p<=m) modify(lson,p,v);
     else modify(rson,p,v);
     update(rt);
 }

 int query(int l,int r,int rt,int nowl,int nowr) {
     if (nowl<=l && r<=nowr) return MAX[rt];
     int ans=INT_MIN;
     int m=(l+r)>>;
     if (nowl<=m) ans=max(ans,query(lson,nowl,nowr));
     if (m<nowr) ans=max(ans,query(rson,nowl,nowr));
     return ans;
 }

二、区间和

区间和是线段树可维护的最基本的信息，其他所有线段树可维护的序列信息，都是以区间和为模板建立的。

1.单点增减、单点替换：

 #define lson l,m,rt<<1
 #define rson m+1,r,rt<<1|1
 void update(int rt){
     sum[rt]=sum[rt<<]+sum[rt<<|];//sum[rt]表示rt节点所包含的区间信息，此处为区间和
 }
 void build(int l,int r,int rt){ //构造线段树
     if (l==r) {
         sum[rt]=a[l];
         return;
     }
     int m=(l+r)>>;
     build(lson);
     build(rson);
     update(rt);
 }
 void modify(int l,int r,int rt,int p,LL v){ //将p位置修改为v
     if (l==r) {
         sum[rt]=v;//如果是将p位置的数+v,则此句应为sum[rt]+=v;
         return;
     }
     int m=(l+r)>>;
     if (p<=m) modify(lson,p,v);
     else modify(rson,p,v);
     update(rt);
 }

 LL query(int l,int r,int rt,int nowl,int nowr) { //询问[nowl,nowr]的信息
     if (nowl<=l && r<=nowr) return sum[rt];
     LL ans=;
     int m=(l+r)>>;
     if (nowl<=m) ans+=query(lson,nowl,nowr);
     if (m<nowr) ans+=query(rson,nowl,nowr);
     return ans;
 }

2.区间增减、区间替换：（测试：洛谷P3372）

 const int M=;
 LL a[M];
 LL sum[M<<],lazy[M<<];
 #define lson l,m,rt<<1
 #define rson m+1,r,rt<<1|1
 void update(int rt){
     sum[rt]=sum[rt<<]+sum[rt<<|];
 }
 void build(int l,int r,int rt){
     lazy[rt]=;//懒标记
     if (l==r) {
         sum[rt]=a[l];
         return;
     }
     int m=(l+r)>>;
     build(lson);
     build(rson);
     update(rt);
 }
 void clean(int rt,int len){//懒标记下移
     if(lazy[rt]){
         lazy[rt<<]+=lazy[rt];//若为区间替换则为“=”
         lazy[rt<<|]+=lazy[rt];//同上
         sum[rt<<]+=lazy[rt]*(len-(len>>));//同上
         sum[rt<<|]+=lazy[rt]*(len>>);//同上
         lazy[rt]=;
     }
 }
 void modify(int l,int r,int rt,int nowl,int nowr,LL v){
     int len=r-l+;
     if (nowl<=l&&r<=nowr) {
         lazy[rt]+=v;//若为区间替换则为“=”
         sum[rt]+=v*len;//同上
         return;
     }
     clean(rt,len);//每次分治前需要下移懒标记，不分治就不下移
     int m=(l+r)>>;
     if(nowl<=m)modify(lson,nowl,nowr,v);
     if(m<nowr)modify(rson,nowl,nowr,v);
     update(rt);
 }
 LL query(int l,int r,int rt,int nowl,int nowr) {
     if (nowl<=l && r<=nowr) return sum[rt];
     clean(rt,r-l+);//同上
     LL ans=;
     int m=(l+r)>>;
     if (nowl<=m) ans+=query(lson,nowl,nowr);
     if (m<nowr) ans+=query(rson,nowl,nowr);
     return ans;
 }

3.区间加减乘混合（测试：洛谷P3373）

 typedef long long LL;
 const int M=;
 LL a[M];
 LL sum[M<<],add[M<<],c[M<<];
 LL p;//模数
 #define lson l,m,rt<<1
 #define rson m+1,r,rt<<1|1
 void update(int rt){
     sum[rt]=(sum[rt<<]+sum[rt<<|])%p;
 }
 void build(int l,int r,int rt){
     add[rt]=;c[rt]=;//加法懒标记和乘法懒标记
     if (l==r) {
         sum[rt]=a[l];
         return;
     }
     int m=(l+r)>>;
     build(lson);
     build(rson);
     update(rt);
 }
 void clean(int rt,int len){
     if(c[rt]!=){//先下移乘法标记，再下移加法标记
         c[rt<<]=c[rt<<]*c[rt]%p;
         c[rt<<|]=c[rt<<|]*c[rt]%p;
         add[rt<<]=add[rt<<]*c[rt]%p;//加法标记也要乘上乘数
         add[rt<<|]=add[rt<<|]*c[rt]%p;
         sum[rt<<]=sum[rt<<]*c[rt]%p;
         sum[rt<<|]=sum[rt<<|]*c[rt]%p;
         c[rt]=;
     }
     if(add[rt]){
         add[rt<<]=(add[rt<<]+add[rt])%p;
         add[rt<<|]=(add[rt<<|]+add[rt])%p;
         sum[rt<<]+=add[rt]*(len-(len>>));sum[rt<<]%=p;
         sum[rt<<|]+=add[rt]*(len>>);sum[rt<<|]%=p;
         add[rt]=;
     }
 }
 void modify(int l,int r,int rt,int nowl,int nowr,LL v){//区间加法
     int len=r-l+;
     if (nowl<=l&&r<=nowr) {
         add[rt]=(add[rt]+v)%p;
         sum[rt]=(sum[rt]+v*len%p)%p;
         return;
     }
     clean(rt,len);
     int m=(l+r)>>;
     if(nowl<=m)modify(lson,nowl,nowr,v);
     if(m<nowr)modify(rson,nowl,nowr,v);
     update(rt);
 }
 void modify_(int l,int r,int rt,int nowl,int nowr,LL v){//区间乘法
     int len=r-l+;
     if(nowl<=l&&r<=nowr){
         c[rt]=c[rt]*v%p;
         add[rt]=add[rt]*v%p;
         sum[rt]=sum[rt]*v%p;
         return;
     }
     clean(rt,len);
     int m=(l+r)>>;
     if(nowl<=m)modify_(lson,nowl,nowr,v);
     if(m<nowr)modify_(rson,nowl,nowr,v);
     update(rt);
 }
 LL query(int l,int r,int rt,int nowl,int nowr) {
     if (nowl<=l && r<=nowr) return sum[rt];
     clean(rt,r-l+);
     LL ans=;
     int m=(l+r)>>;
     if (nowl<=m) ans=(ans+query(lson,nowl,nowr))%p;
     if (m<nowr) ans=(ans+query(rson,nowl,nowr))%p;
     return ans;
 }