线段树板子整理

线段树

参考大神的博客写的：
大神详解（写的真的很好）
tree[i].l和tree[i].r分别表示这个点代表的线段的左右下标，tree[i].sum表示这个节点表示的线段和。

一颗二叉树，她的左儿子和右儿子编号分别是她*2和她*2+1，

建树

inline void build(int i,int l,int r){//递归建树
    tree[i].l=l;tree[i].r=r;
    if(l==r){//如果这个节点是叶子节点
        tree[i].sum=input[l];
        return ;
    }
    int mid=(l+r)>>1;
    build(i*2,l,mid);//分别构造左子树和右子树
    build(i*2+1,mid+1,r);
    tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;//刚才我们发现的性质return ;
}

一、简单（无pushdown）的线段树

1、单点修改，区间查询

我们总结一下，线段树的查询方法：

1. 如果这个区间被完全包括在目标区间里面，直接返回这个区间的值
2. 如果这个区间的左儿子和目标区间有交集，那么搜索左儿子
3. 如果这个区间的右儿子和目标区间有交集，那么搜索右儿子

区间查询(求区间的和)

inline int search(int i,int l,int r){
    if(tree[i].l>=l && tree[i].r<=r)//如果这个区间被完全包括在目标区间里面，直接返回这个区间的值
        return tree[i].sum;
    if(tree[i].r<l || tree[i].l>r)  return 0;//如果这个区间和目标区间毫不相干，返回0
    int s=0;
    if(tree[i*2].r>=l)  s+=search(i*2,l,r);//如果这个区间的左儿子和目标区间又交集，那么搜索左儿子
    if(tree[i*2+1].l<=r)  s+=search(i*2+1,l,r);//如果这个区间的右儿子和目标区间又交集，那么搜索右儿子
    return s;
}

单点修改

然我们怎么修改这个区间的单点，其实这个相对简单很多，你要把区间的第dis位加上k。

那么你从根节点开始，看这个dis是在左儿子还是在右儿子，在哪往哪跑，

然后返回的时候，还是按照tree[i].sum=tree[i*2].sum+tree[i*2+1].sum的原则，更新所有路过的点

inline void add(int i,int dis,int k){
    if(tree[i].l==tree[i].r){//如果是叶子节点，那么说明找到了
        tree[i].sum+=k;
        return ;
    }
    if(dis<=tree[i*2].r)  add(i*2,dis,k);//在哪往哪跑
    else  add(i*2+1,dis,k);
    tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;//返回更新
    return ;
}

书写规范

#include<bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;

int n, a[N], opnum;
int op, pos, L, R, k;

struct segment_tree {
    struct tree {
        int l, r;
        int lazy;
        int sum;
    }tr[N * 4];
    void build(int i, int l, int r) { //创建一棵树，i是节点，l时左边界，r是右边界
        tr[i].l = l, tr[i].r = r; // 该结点的区间[l , r];
        if (l == r) {  //当前为叶节点
            tr[i].sum = a[l]; //叶节点存储的是单个数字且是a数组中的数字
            return;
        }
        int mid = (l + r) >> 1;
        build(i * 2, l, mid); // 递归构造左子树
        build(i * 2 + 1, mid + 1, r); //递归构造右子树
        tr[i].sum = tr[i * 2].sum + tr[i * 2 + 1].sum; //更新结点sum的值，是从下往上确定每个节点的sum的
    }
    inline void add(int i, int dis, int k) {//单点修改，i是节点，dis是修改的位置，k是增加或减少的值
        if (tr[i].l == tr[i].r) { //判断到叶节点的时候说明找到了该数，该数字 + k；
            tr[i].sum += k;
            return;
        }
        if (dis <= tr[i * 2].r) add(i * 2, dis, k); //dis在哪里就往哪边靠
        else add(i * 2 + 1, dis, k); 
        tr[i].sum = tr[i * 2].sum + tr[i * 2 + 1].sum; //从下往上重新确定路径上的节点的sum值
        return;
    }
    inline int serch(int i, int l, int r) { //区间查询，i是节点，要求[l, r]内值的和
        if (tr[i].l >= l && tr[i].r <= r) { //当节点的整个区间都被包含时就返回sum
            return tr[i].sum;
        }
        else if (tr[i].l > r || tr[i].r < l) return 0; // 当节点区间和所求的区间没有任何关系时返回0
        int s = 0;
        if (tr[i * 2 + 1].l <= r) s += serch(i * 2 + 1, l, r); // 当节点的右区间有重合时，就递归往又找，同时累加s
        if (tr[i * 2].r >= l) s += serch(i * 2, l, r); //当节点的左区间有重合时，同理操作
        return s;
    }
}ST;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    cin >> n >> opnum;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    ST.build(1, 1, n); // 建树
    for (int i = 1; i <= opnum; i++) {
        cin >> op;
        if (op == 1) {
            cin >> pos >> k;
            ST.add(1, pos, k); // 单点修改
        }
        else {
            cin >> L >> R;
            int re = ST.serch(1, L, R); // 区间查询
            cout << re << '\n';
        }