线段树

线段树：

       是一种二叉树，它将一个区间划分为一些单元区间，每个单元区间对应线段树中的一个叶结点。对于其中的一个非叶子节点 [ a, b ] ，它的左儿子表示的区间为 [a, (a+b)/2]，右儿子表示的区间为 [ (a+b)/2+1 , b ]。

构造的树如图（不是我的图）帮助理解

基本操作：

1，建树（主要应用递归构造，如果当前节点记录的区间只有一个值，则直接赋值，否则递归构造左右子树，之后回溯时在给当前结点赋值

 

struct lnode
{
    ll left,right,sum,len,mark;
};
lnode num[maxn<<2];
ll rec[maxn];
ll build(ll o,ll l,ll r)
{
    num[o].left=l;
    num[o].right=r;
    num[o].mark=0;
    num[o].len=r-l+1;
    if(l==r)
        return num[o].sum=rec[l];
    ll mid=(num[o].left+num[o].right)>>1;
    return num[o].sum=build(o<<1,l,mid)+build(o<<1|1,mid+1,r);
}

 

 

 

 

2，单点更新

 

struct lnode
{
    int left,right,maxi;
};
lnode rec[maxn<<2];
int build(int left,int right,int node)
{
    rec[node].left=left;
    rec[node].right=right;
    if(left==right)
        return rec[node].maxi=score[left];
    int mid=(left+right)>>1;
    return rec[node].maxi=maxele(build(left,mid,node<<1),build(mid+1,right,node<<1|1));
}
int update(int node,int aim,int val)
{
    rec[node].maxi=maxele(val,rec[node].maxi);
    if(rec[node].left==rec[node].right)
        return rec[node].maxi=val;
    int mid=(rec[node].left+rec[node].right)>>1;
    if(aim<=mid)
        update(node<<1,aim,val);
    else
        update(node<<1|1,aim,val);
}

 

 

 

 

3，区间更新（有用到 lazy 思想）

即是每个节点新增加一个标记，记录这个节点是否进行了修改。对于任意区间的修改，按查询的方式将其划分到线段树中的结点，然后修改结点的信息，并给这些结点标上标记；在修改和查询时，若我们需要用到结点，并要考虑子节点，就看该节点是否有标记，若有标记，则修改其子结点的信息，并给子节点标记，同时将该节点的标记消除。

 

#define ll long long

 

 

 

void pushdown(int o)
{
    if(num[o].mark)//若需要用到的节点并没有更新，则更新<span></span>
    {
        num[o<<1].mark+=num[o].mark;
        num[o<<1|1].mark+=num[o].mark;
        num[o<<1].sum+=num[o].mark*num[o<<1].len;
        num[o<<1|1].sum+=num[o].mark*num[o<<1|1].len;
        num[o].mark=0;
    }
}
void pushup(int o)
{
    num[o].sum=num[o<<1].sum+num[o<<1|1].sum;
}
void update(ll o,ll l,ll r,ll v)
{
    if(l<=num[o].left&&r>=num[o].right)//这里只更新当前节点，并没有继续更新子节点<span></span>
    {
        num[o].mark+=v;
        num[o].sum+=num[o].len*v;
        return ;
    }
    pushdown(o);//更新需要用到的而之前未更新的节点<span>  </span>
    ll mid=(num[o].left+num[o].right)>>1;
    if(r<=mid)//要更新的区间在当前节点的左子树
        update(o<<1,l,r,v);
    else if(l>mid)//要更新的区间在当前节点的右子树<span></span>
        update(o<<1|1,l,r,v);
    else//左右子树都有<span> </span>
    {
        update(o<<1,l,mid,v);
        update(o<<1|1,mid+1,r,v);
    }
    pushup(o);//向上传递（子节点有改变则根节点也会有相应的变化）<span></span>

 

 

4，查询

（这个是查询区间内总和的）

ll query(ll o,ll l,ll r)
{
    if(l<=num[o].left&&r>=num[o].right)
        return num[o].sum;
    pushdown(o);
    ll mid=(num[o].left+num[o].right)>>1;
    ll ans=0;
    if(r<=mid)
        ans+=query(o<<1,l,r);
    else if(l>mid)
        ans+=query(o<<1|1,l,r);
    else
        ans+=query(o<<1,l,mid)+query(o<<1|1,mid+1,r);
    return ans;
}

 

这个是求最大最小值

 

int rec[maxn];
struct lnode
{
    int left,right,max,min;
};
lnode num[maxn<<2];
int maxi(int a,int b)
{
    return a>b?a:b;
}
int mini(int a,int b)
{
    return a<b?a:b;
}
int buildmax(int o,int l,int r)
{
    num[o].left=l;
    num[o].right=r;
    if(l==r)
    {
        num[o].max=rec[l];
        return num[o].max;
    }
    int mid=(l+r)>>1;
    return num[o].max=maxi(buildmax(o<<1,l,mid),buildmax(o<<1|1,mid+1,r));
}
int buildmin(int o,int l,int r)
{
    num[o].left=l;
    num[o].right=r;
    if(l==r)
    {
        num[o].min=rec[l];
        return num[o].min;
    }
    int mid=(l+r)>>1;
    return num[o].min=mini(buildmin(o<<1,l,mid),buildmin(o<<1|1,mid+1,r));
}
int querymax(int o,int l,int r)
{
    if(num[o].left==l&&num[o].right==r)
        return num[o].max;
    int mid=(num[o].left+num[o].right)>>1;
    if(r<=mid)
        return querymax(o<<1,l,r);
    else
    {
        if(l>mid)
            return querymax(o<<1|1,l,r);
        else
            return maxi(querymax(o<<1,l,mid),querymax(o<<1|1,mid+1,r));
    }
}
int querymin(int o,int l,int r)
{
    if(num[o].left==l&&num[o].right==r)
        return num[o].min;
    int mid=(num[o].left+num[o].right)>>1;
    if(r<=mid)
        return querymin(o<<1,l,r);
    else
    {
        if(l>mid)
            return querymin(o<<1|1,l,r);
        else
            return mini(querymin(o<<1,l,mid),querymin(o<<1|1,mid+1,r));
    }
}

 

 

 

 

 

还可以一起写，一次看 的别人的博客里的（其实都一样的）

 

#include <iostream>
#include<cstdio>
#include<cstring>
#define maxn 100000+10
#define ll long long
using namespace std;
struct lnode
{
    ll left,right,sum,mark;
};
lnode num[maxn<<2];
ll rec[maxn];
ll build(ll o,ll l,ll r)
{
    num[o].left=l;
    num[o].right=r;
    num[o].mark=0;
    if(l==r)
        return num[o].sum=rec[l];
    ll mid=(num[o].left+num[o].right)>>1;
    return num[o].sum=build(o<<1,l,mid)+build(o<<1|1,mid+1,r);
}
void update(ll o,ll l,ll r,ll v)
{
    if(l<=num[o].left&&r>=num[o].right)
    {
        num[o].mark+=v;
        return ;
    }
    num[o].sum+=v*(r-l+1);
    ll mid=(num[o].left+num[o].right)>>1;
    if(r<=mid)
        update(o<<1,l,r,v);
    else if(l>mid)
        update(o<<1|1,l,r,v);
    else
    {
        update(o<<1,l,mid,v);
        update(o<<1|1,mid+1,r,v);
    }
}
ll query(ll o,ll l,ll r)
{
    if(l<=num[o].left&&r>=num[o].right)
        return num[o].sum+num[o].mark*(r-l+1);
    if(num[o].mark)
    {
        num[o<<1].mark+=num[o].mark;
        num[o<<1|1].mark+=num[o].mark;
        num[o].sum+=num[o].mark*(num[o].right-num[o].left+1);
        num[o].mark=0;
    }
    ll mid=(num[o].left+num[o].right)>>1;
    ll ans=0;
    if(r<=mid)
        ans+=query(o<<1,l,r);
    else if(l>mid)
        ans+=query(o<<1|1,l,r);
    else
        ans+=query(o<<1,l,mid)+query(o<<1|1,mid+1,r);
    return ans;
}
int main()
{
    ll n,q,a,b,c;
    char s[5];
    while(~scanf("%lld%lld",&n,&q))
    {
        for(int i=1;i<=n;++i)
            scanf("%lld",&rec[i]);
        build(1,1,n);
        while(q--)
        {
            scanf("%s",s);
            if(s[0]=='C')
            {
                scanf("%lld%lld%lld",&a,&b,&c);
                update(1,a,b,c);
            }
            else
            {
                scanf("%lld%lld",&a,&b);
                printf("%lld\n",query(1,a,b));
            }
        }
    }
    return 0;
}