F.r.a.n.k.y

dd=====(·▽·*)bლ(╹◡╹ლ)φ(≧ω≦*)♪= ̄ω ̄=φ(゜▽゜*)♪

线段树初步&&lazy标记

线段树

一.概述:

线段树是一种二叉搜索树,与区间树相似,它将一个区间划分成一些单元区间,每个单元区间对应线段树中的一个叶结点。

对于线段树中的每一个非叶子节点[a,b],它的左儿子表示的区间为[a,(a+b)/2],右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树,最后的子节点数目为N,即整个线段区间的长度。

使用线段树可以快速的查找某一个节点在若干条线段中出现的次数,时间复杂度为O(logN)。而未优化的空间复杂度为2N,因此有时需要离散化让空间压缩。

二.基本操作:

1.建树:主要思想,二分。关系如下:

设一个节点坐标为i,则其父亲节点为i/2,兄弟节点则为i/2*2或i/2*2+1;

由此建树:

 

struct aaa{

      int value;        // 结点对应区间的权值  

      int left,right;   // 区间 [left,right]

}node[2005];

int father[2005];      // 每个点(当区间长度为0时,对应一个点)对应的结构体数组下标

void BuildTree(int i,int left,int right) // 为区间[left,right]建立一个以i为祖先的线段树,i为数组下标,我称作结点序号  

    node[i].left = left;    // 写入第i个结点中的 左区间  

    node[i].right = right;  // 写入第i个结点中的 右区间  

    node[i].value = 0;      // 每个区间初始化为 0  

    if (left == right){ // 当区间长度为 0 时,结束递归  

        father[left] = i; // 能知道某个点对应的序号,为了更新的时候从下往上一直到顶  

        return;  

    }  

    // 该结点往 左孩子的方向 继续建立线段树,线段的划分是二分思想,类二分查找

    // 这里将 区间[left,right] 一分为二了  

    BuildTree(i<<1, left, (int)floor( (right+left) / 2.0));  

    // 该结点往 右孩子的方向 继续建立线段树  

    BuildTree((i<<1) + 1, (int)floor( (right+left) / 2.0) + 1, right);  

}

 

链接: floor函数:向下取整;如floor(9.999)=9;floor(-3.1)=-4;

 a<<1=a*2;a<<=1则是将值赋予a;

2.单点更新:

一遍递归,到根停止。

void UpdataTree(int ri){ // 从下往上更新(注:这个点本身已经在函数外更新过了)  

  

    if (ri == 1)return; // 向上已经找到了祖先(整个线段树的祖先结点 对应的下标为1)  

    int fi = ri / 2;        // ri 的父结点  

    int a = node[fi<<1].value; // 该父结点的两个孩子结点(左)  

    int b = node[(fi<<1)+1].value; //

    node[fi].value = (a > b)?(a):(b);    // 更新这个父结点(从两个孩子结点中挑个大的)  

    UpdataTree(ri/2);       // 递归更新,由父结点往上找  

}  

 

链接:(a > b)?(a):(b)即if(a>b) return a;else return b;

另:

3.查询区间和(by fancy+sui)

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int N=100;
//这个是查询区间和的模板,最大值什么的自己脑补~(如果模板有什么问题的话去找***这个 是她写的2333333(雾)
//                                                                                            --你们认真负责的好学长~ 
struct node
{
   int lc,rc,l,r,sum;
}t[2*N];    
int root,tot;//tot为计数的节点,记录当前用到几号节点了,每次开新节点就++tot 
int a[N];
void build(int x,int l,int r)
{
    t[x].l=l; t[x].r=r;
    if(l==r)
    {
        t[x].sum=a[l];
        return;
    }
    int mid=(l+r)/2;
    t[x].lc=++tot;    build(t[x].lc,l,mid);
    t[x].rc=++tot;    build(t[x].rc,mid+1,r);
    t[x].sum=t[t[x].lc].sum+t[t[x].rc].sum;
}
int query(int x,int l,int r)
{
    if(l<=t[x].l&&t[x].r<=r) return t[x].sum;//若当前区间全有贡献,直接返回 
    int mid=(t[x].l+t[x].r)/2;
    int ans=0;
    if(l<=mid) ans+=query(t[x].lc,l,r); 
    if(mid<r)  ans+=query(t[x].rc,l,r);
    return ans;
}
void change(int x,int v,int d)
{
    if(t[x].l==t[x].r)
    {
        t[x].sum=d;
        return;
    }
    int mid=(t[x].l+t[x].r)/2;
    if(v<=mid) change(t[x].lc,v,d);
    if(mid<v)  change(t[x].rc,v,d);
    t[x].sum=t[t[x].lc].sum+t[t[x].rc].sum;//由两个儿子节点更新自己 
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&a[i]);
    root=++tot;
    build(root,1,n);
    for(int i=1,k,x,y;i<=m;i++)
    {
        scanf("%d%d%d",&k,&x,&y);
        if(k==1) printf("%d\n",query(root,x,y));
        if(k==2) change(root,x,y);
    } 
}

 

4.区间更新

区间更新是指更新某个区间内的叶子节点的值,因为涉及到的叶子节点不止一个,而叶子节点会影响其相应的非叶父节点,那么回溯需要更新的非叶子节点也会有很多,如果一次性更新完,操作的时间复杂度肯定不是O(lgn),例如当我们要更新区间[0,3]内的叶子节点时,需要更新出了叶子节点3,9外的所有其他节点。为此引入了线段树中的延迟标记概念,这也是线段树的精华所在。

延迟标记:每个节点新增加一个标记,记录这个节点是否进行了某种修改(这种修改操作会影响其子节点),对于任意区间的修改,我们先按照区间查询的方式将其划分成线段树中的节点,然后修改这些节点的信息,并给这些节点标记上代表这种修改操作的标记。在修改和查询的时候,如果我们到了一个节点p,并且决定考虑其子节点,那么我们就要看节点p是否被标记,如果有,就要按照标记修改其子节点的信息,并且给子节点都标上相同的标记,同时消掉节点p的标记。

举例说明:当我们要对区间[0,2]的叶子节点增加2,利用区间查询的方法从根节点开始找到了非叶子节点[0-2],把它的值设置为1+2 = 3,并且把它的延迟标记设置为2,更新完毕;当我们要查询区间[0,1]内的最小值时,查找到区间[0,2]时,发现它的标记不为0,并且还要向下搜索,因此要把标记向下传递,把节点[0-1]的值设置为2+2 = 4,标记设置为2,节点[2-2]的值设置为1+2 = 3,标记设置为2(其实叶子节点的标志是不起作用的,这里是为了操作的一致性),然后返回查询结果:[0-1]节点的值4;当我们再次更新区间[0,1](增加3)时,查询到节点[0-1],发现它的标记值为2,因此把它的标记值设置为2+3 = 5,节点的值设置为4+3 = 7;

其实当区间更新的区间左右值相等时([i,i]),就相当于单节点更新,单节点更新只是区间更新的特例。

 

因此需要在线段树结构中加入延迟标记域,本文例子中我们加入标记与addMark,表示节点的子孙节点在原来的值的基础上加上addMark的值,同时还需要修改创建函数build 和 查询函数 query,修改的代码用红色字体表示,其中区间更新的函数为update,代码如下:(不建议看但还是粘在这里)

 

 

 const int INFINITE = INT_MAX;

 const int MAXNUM = 1000;

 struct SegTreeNode

 {

     int val;

     int addMark;//延迟标记

 }segTree[MAXNUM];//定义线段树





 void build(int root, int arr[], int istart, int iend)

 {

     segTree[root].addMark = 0;//----设置标延迟记域

     if(istart == iend)//叶子节点

         segTree[root].val = arr[istart];

     else

     {

         int mid = (istart + iend) / 2;

         build(root*2+1, arr, istart, mid);//递归构造左子树

         build(root*2+2, arr, mid+1, iend);//递归构造右子树

         //根据左右子树根节点的值,更新当前根节点的值

         segTree[root].val = min(segTree[root*2+1].val, segTree[root*2+2].val);

     }

 }





 void pushDown(int root)

 {

     if(segTree[root].addMark != 0)

     {

         //设置左右孩子节点的标志域,因为孩子节点可能被多次延迟标记又没有向下传递

         //所以是 “+=”

         segTree[root*2+1].addMark += segTree[root].addMark;

         segTree[root*2+2].addMark += segTree[root].addMark;

         //根据标志域设置孩子节点的值。因为我们是求区间最小值,因此当区间内每个元

         //素加上一个值时,区间的最小值也加上这个值

         segTree[root*2+1].val += segTree[root].addMark;

         segTree[root*2+2].val += segTree[root].addMark;

         //传递后,当前节点标记域清空

         segTree[root].addMark = 0;

     }

 }





 int query(int root, int nstart, int nend, int qstart, int qend)

 {

     //查询区间和当前节点区间没有交集

     if(qstart > nend || qend <<span style="font-family: 'Courier New' !important;"> nstart)

         return INFINITE;

     //当前节点区间包含在查询区间内

     if(qstart <= nstart && qend >= nend)

         return segTree[root].val;

     //分别从左右子树查询,返回两者查询结果的较小值

     pushDown(root); //----延迟标志域向下传递

     int mid = (nstart + nend) / 2;

     return min(query(root*2+1, nstart, mid, qstart, qend),

                query(root*2+2, mid + 1, nend, qstart, qend));



 }




void update(int root, int nstart, int nend, int ustart, int uend, int addVal)

 {

     //更新区间和当前节点区间没有交集

     if(ustart > nend || uend <<span style="font-family: 'Courier New' !important;"> nstart)

         return ;

     //当前节点区间包含在更新区间内

     if(ustart <= nstart && uend >= nend)

     {

         segTree[root].addMark += addVal;

         segTree[root].val += addVal;

         return ;

     }

     pushDown(root); //延迟标记向下传递

     //更新左右孩子节点

     int mid = (nstart + nend) / 2;

     update(root*2+1, nstart, mid, ustart, uend, addVal);

     update(root*2+2, mid+1, nend, ustart, uend, addVal);

     //根据左右子树的值回溯更新当前节点的值

     segTree[root].val = min(segTree[root*2+1].val, segTree[root*2+2].val);

 }

 

 

 

 

 

参考:codestorm  x314542916

posted on 2016-08-28 20:21  Franky==  阅读(696)  评论(0编辑  收藏  举报

导航