线段树初级

线段树的基本概念与应用

    1.     线段树是一颗二叉搜索树，它的每个结点存储的是一个区间的信息。

    2.     线段树的存储是以结构体的形式进行的，每个结点需包含所维护区间的左，右端点，

            区间所需维护的信息。

    3.    使用线段树可以快速的查询所需信息，它的时间复杂度为O(logN),而未优化的空间复

            杂度为2N，实际应用时一般要开到4N以避免越界。

 

线段树的基础操作

         线段树的基础操作包括：建树，单点修改，单点查询，区间修改，区间查询。

        （以下操作皆以求和为例）

 

结点创建：

struct node
{
    int l,r; //所维护区间左右端点
    int w;   //区间所存储信息
}tree[4*MAXN];

 

1.  建树

思路：对于每一个结点，确定它的左右端点值；如果是叶子结点，存储它的端点值，否则进行状态合并。

void Build(int k,int l,int r)
{
    tree[k].l=l,tree[k].r=r;
    if(tree[k].l==tree[k].r)
    {
        scanf("%d",&tree[k].w);
        return;
    }
    int mid=(l+r)/2;
    build(2*k,l,mid); //左孩子
    build(2*k+1,mind+1,r); //右孩子
    tree[k].w=tree[2*k].w+tree[2*k+1].w; //状态合并
    return;
}

 

2.单点查询

思路：首先查询的思想很明显是二分。如果查询的当前结点所维护的区间左端点等于右端点，该点为叶子结点，也即目标结点。如果不是叶子结点，假设所查询的端点为x,当前结点的左右端点分别为 l , r ，中点为mid，如果x<=mid,则递归它的左孩子，否则递归它的右孩子，直到找到目标结点为止。

void query_point(int k)
{
    if(tree[k].r==tree[k].l)   //左右端点相等，为叶子结点
    {
        ans=tree[k].w;
        return;
    }
    int mid=(tree[k].l+tree[k].r)/2;
    if(x<=mid) query_point(2*k);    //目标位置在左侧，递归左孩子
    else query_point(2*k+1);        //目标位置在右侧，递归右孩子
}

 

3.单点修改

思路：根据单点查询的原理，找到叶子结点，更改它的值，并且修改所有被它所影响的结点的值。

例：找到目标结点x,并且将该结点加上y；

void change_point(int k)
{
    if(tree[k].l==tree[k].r)
    {
        tree[k].w+=y;
        return;
    }
    int mid=(tree[k].l+tree[k].r)/2;
    if(x<=mid) change_point(2*k);
    else change_point(2*k+1);
    tree[k].w=tree[2*k].w+tree[2*k+1].w; //所有包含x的结点的值的更新，递归思想
    return ;
}

 

4.区间查询

思路：查询区间为（ a , b ）;当前结点区间为（ l , r ）;

          ①  当前结点区间(l,r)全在查询区间(a,b)中；

                 a____l____r_____b          直接加上当前结点区间的状态。

          ②  当前结点区间只有一部分在查询区间中；

                a____l____b_____r          暂时不加当且结点状态，根据区间端点与终点的位置关系，

               继续递归左孩子或者右孩子，直到满足情况①。

          ③ 当前结点区间包含了待查询区间；

                l____a____b_____r          根据a,b与mid的情况向下走；

                mid=(l+r)/2;

                b<=mid,查询区间全在左子区间，向左孩子走；

                a>mid，查询区间全在右子区间，向右孩子走；

                否则，左，右子区间都走；

void query_interval(int k)
{
    if(a<=tree[k].l&&b>=tree[k].r)
    {
        ans+=tree[k].w;
        return ;
    }
    int mid=(tree[k].l+tree[k].r)/2;
    if(a<=mid) query_interval(2*k);
    if(b>mid) query_interval(2*k+1);

 

5.区间修改

区间修改相对与上面的几个操作来说，较为复杂。

例如，现在需要将区间[a,b]内的每个数都加上y；

如果向之前单点修改那样，将所有受到这次修改操作影响的结点全部修改，在输出区间[a,b]的值；

那也太复杂了，如果这个树的深度很深，会非常耗时，与我们使用线段树的初衷不符。

事实上对于区间[a,b]来说，它的子区间的值是不需要改变的，我们根本用不到；

假设[a,b]包含于二叉树的一个结点k中，对于以k为祖先的所有孩子结点的值我们是不需要更改的；

所以，只需修改对当前查询有影响的结点！

为了实现这个操作，这里引入新的状态标记—懒惰标记。

 

懒惰标记

原结构体中需增加懒惰标记变量；

作用：存储这个结点的修改信息，暂时不把他传递给子节点。

进行操作时，找到需要更改的结点时，只需要更新这个结点的状态，把懒惰标记累加上去；

需要用到它的子节点时，才把懒惰标记传递给它的子节点，此时，子结点的状态应该为：

初状态+父亲下传的懒惰标记*区间元素个数（注意，这里必须时父亲下传的懒惰标记，而非自己的）；

如果是自己的，可能是父亲多次传下来的累计，每次都乘自己的会有重复。

下传后懒惰标记需要清0；

懒惰标记下传代码：

void down(int k)
{
    tree[2*k].f+=tree[k].f;  //懒惰标记下传给左儿子
    tree[2*k+1].f+=tree[k].f; //懒惰标记下传给右儿子
    tree[2*k].w+=tree[k].f*(tree[2*k].r-tree[2*k].l+1); //左儿子状态更新
    tree[2*k+1].w+=tree[k].f*(tree[2*k+1].r-tree[2*k+1].l+1); //右儿子状态更新
    tree[k].f=0;  //父亲结点懒惰标记清零
    return;
}

区间修改代码：

void change_interval(int k)
{
    if(tree[k].l>=a&&tree[k].r<=b)
    {
        tree[k].w+=(tree[l].r-tree[k].l+1)*y;
        tree[k].f+=y;
        return;
    }
    if(tree[k].f) down(k);
    int mid=(tree[k].l+tree[k].r)/2;
    if(a<=mid) change_interval(2*k);
    if(b>mid) change_interval(2*k+1);
    tree[k].w=tree[k*2].w+tree[k*2+1].w;
}

懒惰坐标的引用将很多用不到的状态存了起来，会对，其他操作造成影响；

所以在进行单点查询，单点修改，区间查询的时候也需对用的着的懒惰标记进行下传；

即加入:

if(tree[k].f) down(k);

其余不变。

 

五种基本操作完整代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

struct node
{
    int l,r,w;
    int f;//懒惰标记
} tree[4*maxn];
//建树
void build(int k,int l,int r)
{
    tree[k].l=l,tree[k].r=r;
    if(tree[k].l==tree[k].r)
    {
        scanf("%d",&tree[k].w);
        return;
    }
    int mid=(l+r)/2;
    build(2*k,l,mid);
    build(2*k+1,mind+1,r);
    tree[k].w=tree[2*k].w+tree[2*k+1].w;
    return;
}
//懒坐标下传
void down(int k)
{
    tree[2*k].f+=tree[k].f;
    tree[2*k+1].f+=tree[k].f;
    tree[2*k].w+=tree[k].f*(tree[2*k].r-tree[2*k].l+1);
    tree[2*k+1].w+=tree[k].f*(tree[2*k+1].r-tree[2*k+1].l+1);
    tree[k].f=0;
    return;
}
//单点查询
void query_point(int k)
{
    if(tree[k].r==tree[k].l)
    {
        ans=tree[k].w;
        return;
    }
    int mid=(tree[k].l+tree[k].r)/2;
    if(tree[k].f) down(k);
    if(x<=mid) ask_point(2*k);
    else ask_point(2*k+1);
}
//单点修改
void change_point(int k)
{
    if(tree[k].l==tree[k].r)
    {
        tree[k].w+=y;
        return;
    }
    if(tree[k].f) down(k);
    int mid=(tree[k].l+tree[k].r)/2;
    if(x<=mid) change_point(2*k);
    else change_point(2*k+1);
    tree[k].w=tree[2*k].w+tree[2*k+1].w;
    return ;
}
//区间查询
void query_interval(int k)
{
    if(a<=tree[k].l&&b>=tree[k].r)
    {
        ans+=tree[k].w;
        return ;
    }
    if(tree[k].f) down(k);
    int mid=(tree[k].l+tree[k].r)/2;
    if(a<=mid) query_interval(2*k);
    if(b>mid) query_interval(2*k+1);
}
//区间修改
void change_interval(int k)
{
    if(tree[k].l>=a&&tree[k].r<=b)
    {
        tree[k].w+=(tree[l].r-tree[k].l+1)*y;
        tree[k].f+=y;
        return;
    }
    if(tree[k].f) down(k);
    int mid=(tree[k].l+tree[k].r)/2;
    if(a<=mid) change_interval(2*k);
    if(b>mid) change_interval(2*k+1);
    tree[k].w=tree[k*2].w+tree[k*2+1].w;
}