线段树基础总结

线段树几个基本操作

• 单点查询
• 单点修改
• 区间查询
• 区间修改
• 区间求最大值

主要思想：

将一个线性的一维数组构建成树形的数组，使得可以用二分的思想来进行区间操作，降低时间复杂度，但是多占用了空间，典型的用空间换时间。

一个特殊的模块：

lazy数组，考虑到对区间的操作有很多次，并且没有必要每一次对区间的操作都更新到点，只需要在需要的时候更新点就可以了。所以用lazy数组来标记一下对该区间里的数进行的操作。

线段树架构：

• 递归建树便于更新
• 递归操作同样便于更新

解释代码（以线段树求区间最大值为例，顺便说一下区间求和）：

HDU - 1754 

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#include<stack>
#include<deque>
#include<map>
#include<iostream>
using namespace std;
typedef long long  LL;
const double pi=acos(-1.0);
const double e=exp(1);
//const int MAXN =2e5+10;
const int N = 200010*4;

#define lson i << 1,l,m
#define rson i << 1 | 1,m + 1,r
typedef struct Node
{
    LL l;
    LL r;
    LL mid()
    {
        return (l+r)/2;
    }
} Node;

LL ans;
Node node[N];
LL add[N];
LL sum[N];


//void PushUp(LL i)
//{
//    sum[i]=sum[i<<1]+sum[i<<1 | 1];　　　　//对左右子树进行求和
//}
void PushUp(LL i)
{
    sum[i]=max(sum[i<<1],sum[i<<1 | 1]);    //找左右子树的最大值
}

void build(LL i,LL l,LL r)  
{
    node[i].l=l;        //这几行是递，在这个过程中初始化、赋初值
    node[i].r=r;
    sum[i]=0;
    add[i]=0;
    if(l==r)
    {
        scanf("%lld",&sum[i]);      //到达了最后一层的叶子节点，开始取数
        return ;
    }

    LL m=node[i].mid();     //判断建进左子树还是右子树
    build(lson);            
    build(rson);
    PushUp(i);          //归的过程，对区间进行更新
}

void PushDown(LL i,LL L)        //add[i]代表的是对区间中的每一个数应该进行的操作，所以他的子节点应该和他一样，且子节点的值应当是区间中数的个数乘以每个数的改变值
{
    if(add[i])
    {
        add[i << 1]+=add[i];
        add[i<< 1 | 1]+=add[i];
        sum[i << 1]+=add[i]*(L-(L >> 1));
        sum[i << 1 | 1]+=add[i]*(L >> 1);
        add[i]=0;
    }
}

void line_update(LL v,LL l,LL r,LL i)
{
    if(node[i].l==l&&node[i].r==r)      //找到了那个区间（点），进行更新
    {
        sum[i]+=v*(r-l+1);
        add[i]+=v;
        return ;
    }
    //PushDown(i,node[i].r-node[i].l+1);
    LL m=node[i].mid();
    if(r<=m)
        line_update(v,l,r,i <<1);
    else
    {
        if(l>m)
            line_update(v,l,r,i<<1 | 1);
        else
        {
            line_update(v,l,m,i << 1);
            line_update(v,m+1,r,i << 1 | 1);
        }
    }
    PushUp(i);      //因为点被更新过了，所以要对与他有关都更新
}

LL query(LL l,LL r,LL i)
{
    if(node[i].l==l&&node[i].r==r)
    {
        return sum[i];
    }
    PushDown(i,node[i].r-node[i].l+1);
    LL m=node[i].mid();
    LL ans=0;        //确保最大值是要求区间的
    if(r<=m)
        ans=max(query(l,r,i << 1),ans);         
    else
    {
        if(l>m)
            ans=max(query(l,r,i << 1 | 1),ans);
        else
        {
            ans=max(query(l,m,i << 1),ans);
            ans=max(query(m+1,r,i << 1 | 1),ans);
        }
    }
    return ans;
 //   ans=max(ans,sum[i]);
}

void spot_update(LL v,LL l,LL r,LL i)
{
    if(node[i].l==l&&node[i].r==r)
    {
        sum[i]=v;
        return ;
    }
    LL m=node[i].mid();
    if(r<=m)
        spot_update(v,l,r,i << 1);
    else
    {
        if(l>m)
            spot_update(v,l,r,i << 1 | 1);
        else
        {
            spot_update(v,l,m,i << 1);
            spot_update(v,m+1,r,i << 1 | 1);
        }
    }
    PushUp(i);
}

int main()
{
    LL n,q,i,p,j,t,m;
    LL a,b,c;
    char cc;

    while(scanf("%lld%lld",&n,&m)!=EOF)
    {
        build(1,1,n);
        while(m--)
        {
            scanf(" %c",&cc);

            if(cc=='Q')
            {
                ans=0;
                scanf("%lld%lld",&a,&b);
                printf("%lld
",query(a,b,1));
            }
            else if(cc=='U')
            {
                scanf("%lld%lld",&a,&b);
                spot_update(b,a,a,1);

            }
            getchar();
        }
    }

//        else if(cc==-1)
//        {
//            scanf("%lld%lld%lld",&a,&b,&c); //给区间[a,b]+c
//            line_update(c,a,b,1);
//        }

    return 0;
}