线段树 单点修改，区间查询/修改/求和模板

单点修改，区间求和

#include<cstdio>
const int maxn=50000;
int sum[4*maxn];  //求和
int node[maxn]; //存原数组下标
void pushup(int rt)    //更新节点信息  这里是求和
{
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}
 // build 建树
void bulid(int l,int r,int rt)  //[l,r]表示当前结点区间
{                               //rt表示当前节点的实际存储位置
    if(l==r)   //若到达叶节点
    {
        sum[rt]=node[l]; //存出node数组的值
        return ;
    }
    int m=(l+r)>>1;
    //左右递归
    bulid(l,m,rt<<1);
    bulid(m+1,r,rt<<1|1);
    //更新信息
    pushup(rt);
}
//  点增加 node[L]+=C:
void update(int L,int C,int l,int r,int rt) //l,r表示当前节点区间，rt表示当前节点编号
{
    if(l==r)  //到达叶节点，修改叶节点的值
    {
        sum[rt]+=C;
        return ;
    }
    int m=(l+r)>>1;
    //根据条件判断往左子树调用还是往右
    if(L<=m)
        update(L,C,l,m,rt<<1);
    else
        update(L,C,m+1,r,rt<<1|1);
    pushup(rt); //子节点的信息更新了，所以本节点也要更新信息
}
// L~R区间求和
int query(int L,int R,int l,int r,int rt)  //[L,R]表示操作区间，[l,r]表示当前区间
                                           //rt:当前节点编号
{
    if(L<=l && r<=R)           //在区间内直接返回
        return sum[rt];
    int m=(l+r)>>1;  //左子区间:[l,m] 右子区间：[m+1,r]  求和区间:[L,R]
    //累加答案
    int ans=0;
    if(L<=m)
        ans+=query(L,R,l,m,rt<<1);  //左子区间与[L,R]有重叠，递归
    if(R>m)
        ans+=query(L,R,m+1,r,rt<<1|1);  //右子区间与[L,R]有重叠，递归
    return ans;

}

 区间修改

int node[maxn/2];  //原数组
int sum[maxn];     //求和数组
int add[maxn];   //标记数组
void pushup(int rt)
{
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}

void color(int l,int r,int c,int rt)    //标记l~r区间
{
    sum[rt]+=c*(r-l+1);
    add[rt]+=c;
/*一旦修改区间包含当前区间，我们就在当前区间记录下要加的值，这就是add数组，等到我们需要查询该结点的子结点时，我们在将标记下放，再对子结点的sum进行修改。 
如该段代码，打标记时，先把本身加上这个值，再记录下要给子结点加值，这样就完成了打标记的步骤。*/
}

void push_color(int l,int r,int rt)    //标记下放
{//先判断是否有标记，没有就返回,有的话，就二分区间，给两个子结点染色（打标记），然后把当前标记清空即可。
    if(add[rt])
    {
        int m=(l+r)>>1;
        color(l,m,add[rt],rt<<1);
        color(m+1,r,add[rt],rt<<1|1);
        add[rt]=0;   //取消标记
    }
}
//建树
void bulid(int l,int r,int rt)
{
    if(l==r)
    {
        sum[rt]=node[l];
        add[rt]=0;  
        return ;
    }
    int m=(l+r)>>1;
    bulid(l,m,rt<<1);
    bulid(m+1,r,rt<<1|1);
    pushup(rt);
}

// 区间增值修改
void update(int L,int R,int c,int l,int r,int rt)  //L~R区间加 c
{
/*首先判断修改区间是否完全包含此区间， 
包含的话，就直接打标记。 
如果不是，那么就下放一次标记，然后再看是否覆盖到了左右子结点。 
对对应的子结点修改。 
最后再update一下即可。*/

    if(L<=l && R>=r)
    {
        color(l,r,c,rt);
        return ;
    }
    push_color(l,r,rt);
    int m=(l+r)>>1;
    if(L<=m)
        update(L,R,c,l,m,rt<<1);
    if(m<R)
        update(L,R,c,m+1,r,rt<<1|1);
    pushup(rt);
}

ll query(int L,int R,int l,int r,int rt)  //L~R 区间求和
{
    if(L<=l && r<=R)
        return sum[rt];
    push_color(l,r,rt);
    int m=(l+r)>>1;
    ll ans=0;
    if(L<=m)
        ans+=query(L,R,l,m,rt<<1);
    if(R>m)
        ans+=query(L,R,m+1,r,rt<<1|1);
    return ans;
}

 

结构体

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
typedef long long ll;
const int maxn = 1e5+10;
struct node
{
    int l,r,w;
    int f;  //懒作标记
}t[maxn<<2];
void build(int l,int r,int rt)  //建树
{
    t[rt].l = l;
    t[rt].r = r;
    if(l==r)
    {
        scanf("%d",&t[rt].w);
        return ;
    }
    int m = (t[rt].l+t[rt].r)>>1;
    build(l,m,rt<<1);
    build(m+1,r,rt<<1|1);
    t[rt].w = t[rt<<1].w+t[rt<<1|1].w;
}
void down(int rt)       //懒作标记
{
    t[rt<<1].f += t[rt].f;
    t[rt<<1|1].f += t[rt].f;
    t[rt<<1].w = t[rt].f * (t[rt<<1].r-t[rt<<1].l+1);
    t[rt<<1|1].w += t[rt].f * (t[rt<<1|1].r-t[rt<<1|1].l+1);
    t[rt].f = 0;
}
void single_update(int x,int c,int rt)  //单点修改   在x点加上 c
{
    if(t[rt].l==t[rt].r)
    {
        t[rt].w += c;
        return ;
    }
    int m = (t[rt].l+t[rt].r)>>1;
    if(x<=m)
        single_update(x,c,rt<<1);
    else
        single_update(x,c,rt<<1|1);
    t[rt].w = t[rt<<1].w+t[rt<<1|1].w;
}
int single_query(int x,int rt)   //单点查询
{
    if(t[rt].l==t[rt].r)
    {
        return t[rt].w;
    }
    if(t[rt].f)
        down(rt);
    int m = (t[rt].l+t[rt].r)>>1;
    if(x<=m)
        single_query(x,rt<<1);
    else
        single_query(x,rt<<1|1);
}
void update(int x,int y,int z,int rt)  //区间修改 给区间x~y加上z
{
    if(t[rt].l>=x && t[rt].r<=y)
    {
        t[rt].w += (t[rt].r-t[rt].l+1) * z;
        t[rt].f += z;
        return ;
    }
    if(t[rt].f)
        down(rt);
    int m = (t[rt].l+t[rt].r)>>1;
    if(x<=m)
        update(x,y,z,rt<<1);
    if(y>m)
        update(x,y,z,rt<<1|1);
    t[rt].w = t[rt<<1].w + t[rt<<1|1].w;
}
int query(int x,int y,int rt)  //区间查询  查询x~y的和
{
    if(t[rt].l>=x && t[rt].r<=y)
    {
        return t[rt].w;
    }
    if(t[rt].f)
        down(rt);
    int m = (t[rt].l+t[rt].r)>>1;
    int ans = 0;
    if(x<=m)
        ans += query(x,y,rt<<1);
    if(y>m)
        ans += query(x,y,rt<<1|1);
    return ans;
}
int main()
{
    int t,n,m;
    int k,x,y,z;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        build(1,n,1);
        scanf("%d",&m);
        for(int i=0;i<m;i++)
        {
            scanf("%d",&k);
            if(k==0)  //单点修改
            {
                scanf("%d%d",&x,&y);
                single_update(x,y,1);
            }
            else if(k==1)  //单点查询
            {
                scanf("%d",&x);
                printf("%d\n",single_query(x,1));
            }
            else if(k==2)  //区间修改
            {
                scanf("%d%d%d",&x,&y,&z);
                update(x,y,z,1);
            }
            else if(k==3)  //区间查询
            {
                scanf("%d%d",&x,&y);
                printf("%d\n",query(x,y,1));
            }
        }
    }
    return 0;
}

参考博客

 https://blog.csdn.net/zearot/article/details/52280189?utm_source=blogxgwz0

https://blog.csdn.net/cggwz/article/details/78398856#1区间和查询

https://blog.csdn.net/Mercury_Lc/article/details/81393950