线段树

原理

（注：由于线段树的每个节点代表一个区间，以下叙述中不区分节点和区间，只是根据语境需要，选择合适的词）

线段树本质上是维护下标为1,2,..,n的n个按顺序排列的数的信息

所以 其实是“点树” 是维护n的点的信息 至于每个点的数据的含义可以有很多

在对线段操作的线段树中 每个点代表一条线段 在用线段树维护数列信息的时候 每个点代表一个数 但本质上都是每个点代表一个数

以下 在讨论线段树的时候 区间[L,R]指的是下标从L到R的这(R-L+1)个数 而不是指一条连续的线段

只是有时候这些数代表实际上一条线段的统计结果而已

线段树是将每个区间[L,R]分解成[L,M]和[M+1,R] (其中M=(L+R)/2 这里的除法是整数除法，即对结果下取整)直到 L==R 为止

开始时是区间[1,n]  通过递归来逐步分解 假设根的高度为1的话 树的最大高度为（n>1）

线段树对于每个n的分解是唯一的 所以n相同的线段树结构相同

下图展示了区间[1,13]的分解过程：

上图中 每个区间都是一个节点 每个节点存自己对应的区间的统计信息

代码

单点修改

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<string>
#include<algorithm>
#include<map>
#include<queue>
#include<stack>
#include<set>
#include<vector>
using namespace std;
typedef long long ll;
const int maxn = 5e5 + 5; 
int l[4 * maxn], r[4 * maxn];
ll sum[4 * maxn];
void build(int L, int R, int now)//输入的时候L是1，R是数列长度，now == 1 
{
    l[now] = L; r[now] = R;
    if(L == R)
    {
        /* 递归边界：左右端点重合，说明此时区间里只有一个元
        素，正好就可以读入数据，而且此时读入的也正好是该区间
        的区间和 */ 
        scanf("%lld", &sum[now]);
        return ;
    }
    int mid = (L + R) >> 1;
    build(L, mid, now << 1);    //构建左子树 
    build(mid + 1, R, now << 1 | 1);//构建右子树，注意从 mid + 1开始 
    sum[now] = sum[now << 1] + sum[now << 1 | 1];
    // 该区间和就等于左右子区间和的加和 
}

void update(int idx, int d, int now){//idx为输入数列中的序号， d为增加值， now == 1 
    //idx 代表结点编号，d 代表这个数加上 d 
    sum[now] += d;
    if (l[now] == r[now]) return;    //到达叶结点了 
    int mid = (l[now] + r[now]) >> 1;
    //然后判断要更新的点在左还是右子树中
    if (idx <= mid) update(idx, d, now << 1);
    else update(idx, d, now << 1 | 1);
}


ll query(int L, int R, int now){//L R表示区间[L, R], now == 1, 函数返回值为区间和 
    if (L == l[now] && R == r[now]) return sum[now];
    int mid = (l[now] + r[now]) >> 1;
    if (R <= mid) return query(L, R, now << 1);
    else if (L > mid) return query(L, R, now << 1 | 1);
    else return query(L, mid, now << 1) + query(mid + 1, R, now << 1 | 1);
    //没什么好解释的吧，很好理解 
}

int main() 
{
     int n, q; scanf("%d%d", &n, &q);
     build(1, n, 1);
     while(q--)
     {
         int op, a, b; scanf("%d%d%d", &op, &a, &b);
         if (op == 1) update(a, b - query(a, a, 1), 1);
         else printf("%lld
", query(a, b, 1));
      }
      return 0;
}

区间修改

1.区间加值

//区间加值 
#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<string>
#include<algorithm>
#include<map>
#include<queue>
#include<stack>
#include<set>
#include<vector>
typedef long long ll;
using namespace std;
void pushup(int o) {
    　　　　　　　　　　//pushup函数，该函数本身是将当前结点用左右子节点的信息更新，此处求区间和，用于update中将结点信息传递完返回后更新父节点
    st[o] = st[o<<1] + st[o<<1|1];
}

void pushdown(int o,int l,int r) {
    　　//pushdown函数，将o结点的信息传递到左右子节点上
    if(add[o]) {
        　　　　　　　　　　　　　//当父节点有更新信息时才向下传递信息
        add[o<<1] += add[o];
        　　　　　　//左右儿子结点均加上父节点的更新值
        add[o<<1|1]+=add[o];
        int m=l+((r-l)>>1);
        st[o<<1]+=add[o]*(m-l+1);
        　　//左右儿子结点均按照需要加的值总和更新结点信息
        st[o<<1|1]+=add[o]*(r-m);
        add[o]=0;
        　　　　　　　　　　　　　　　　//信息传递完之后就可以将父节点的更新信息删除
    }
}

void update(int o,int l,int r,int ql,int qr,int addv) {
    　　//ql、qr为需要更新的区间左右端点，addv为需要增加的值
    if(ql<=l&&qr>=r) {
        　　　　　　　　　　　　　　　　　　　　　　//与单点更新一样，当当前结点被需要更新的区间覆盖时
        add[o]+=addv;
        　　　　　　　　　　　　　　　　　　　　　　//更新该结点的所需更新信息
        st[o]+=addv*(r-l+1);
        　　　　　　　　　　　　　　　　//更新该结点信息
        return;
        　　　　　　　　　　　　　　　　　　　　//根据lazy思想，由于不需要遍历到下层结点，因此不需要继续向下更新，直接返回
    }

    pushdown(o,l,r);
    　　　　　　　　　　　　　　　　　　//将当前结点的所需更新信息传递到下一层（其左右儿子结点）
    int m=l+((r-l)>>1);
    if(ql<=m)update(o<<1,l,m,ql,qr,addv);
    　　　　　//当需更新区间在当前结点的左儿子结点内，则更新左儿子结点
    if(qr>=m+1)update(o<<1|1,m+1,r,ql,qr,addv);
    　　　//当需更新区间在当前结点的右儿子结点内，则更新右儿子结点
    pushup(o);
    　　　　　　　　　　　　　　　　　　//递归回上层时一步一步更新回父节点
}

ll query(int o,int l,int r,int ql,int qr) {
    　　　　//ql、qr为需要查询的区间
    if(ql<=l&&qr>=r) return st[o];
    　　　　　　//若当前结点覆盖区间即为需要查询的区间，则直接返回当前结点的信息
    pushdown(o,l,r);
    　　　　　　　　　　　　　　　　　　//将当前结点的更新信息传递给其左右子节点
    int m=l+((r-l)>>1);
    ll ans=0;
    　　　　　　　　　　　　　　　　　　　　　　//所需查询的结果
    if(ql<=m)ans+=query(o<<1,l,m,ql,qr);
    　　　　　//若所需查询的区间与当前结点的左子节点有交集，则结果加上查询其左子节点的结果
    if(qr>=m+1)ans+=query(o<<1|1,m+1,r,ql,qr);
    　//若所需查询的区间与当前结点的右子节点有交集，则结果加上查询其右子节点的结果
    　　 return ans;
}

2.区间改值

// 区间改值（其实只有pushdow函数和update中修改部分与区间加值不同） 
#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<string>
#include<algorithm>
#include<map>
#include<queue>
#include<stack>
#include<set>
#include<vector>
typedef long long ll;
using namespace std;
void pushup(int o){
     st[o]=st[o<<1]+st[o<<1|1];
 }
 
 void pushdown(int o,int l,int r){　　//pushdown和区间加值不同，改值时修改结点信息只需要对修改后的信息求和即可，不用加上原信息
     if(change[o]){
         int c=change[o];
         change[o<<1]=c;
         change[o<<1|1]=c;
         int m=l+((r-l)>>1);
         st[o<<1]=(m-l+1)*c;
         st[o<<1|1]=(r-m)*c;
         change[o]=0;
     }
 }
 
 void update(int o,int l,int r,int ql,int qr,int c){
     if(ql<=l&&qr>=r){　　　　　　　　　//同样更新结点信息和区间加值不同
         change[o]=c;
         st[o]=(r-l+1)*c;
         return;
     }
     
     pushdown(o,l,r);
     int m=l+((r-l)>>1);
     if(ql<=m)update(o<<1,l,m,ql,qr,c);
     if(qr>=m+1)update(o<<1|1,m+1,r,ql,qr,c);
     pushup(o);
 }
 
 int query(int o,int l,int r,int ql,int qr){
     if(ql<=l&&qr>=r) return st[o];
     pushdown(o,l,r);
     int m=l+((r-l)>>1);
     int ans=0;
     if(ql<=m)ans+=query(o<<1,l,m,ql,qr);
     if(qr>=m+1)ans+=query(o<<1|1,m+1,r,ql,qr);
     return ans;
 }