线段树的总结

最新推荐文章于 2019-03-03 14:45:13 发布

i-o07

最新推荐文章于 2019-03-03 14:45:13 发布

阅读量499

点赞数

分类专栏：心得总结

本文链接：https://blog.csdn.net/u013649253/article/details/38677203

版权

心得总结专栏收录该内容

1 篇文章 0 订阅

订阅专栏

线段树

线段树是擅长处理区间的一棵完美二叉树（所有的叶子的深度相同，并且每个节点要么是叶子要么是有两个儿子的树），树上的每个节点都维护一个区间，根维护的是整个区间，每个节点维护的是父亲的区间二等分后的其中一个子区间。

线段树的修改分为区间修改和点修改，查询分为点查询和区间查询。

初始化函数：

void init(int n_)
{
    n=1;
    while(n<n_) n*=2;
    for(int i=0;i<2*n-1;i++) dat[i]=0;
}

点修改：

在更新线段树的某个节点ai时，需要对包含i的所有区间对应的节点的值重新进行计算，在更新时，可以从下面的节点开始向上不断更新。

单点更新函数：（以区间求和为例）

void update(int k,int a)
{
    k+=n-1;
    dat[k]=a;
    while(k>0){
        k=(k-1)/2;
        dat[k]=dat[k*2+1]+dat[k*2+2]; 
    }
}

区间修改：

区间修改需要给线段树增加新的域（就是维护多个值），中间有些会用到懒标记和懒标记下发函数（例如区间赋值），有些不会用到如区间加值，

下面分别给出这两个模板。

区间赋值：(Push_Down为下放函数)
void Push_Down(int k,int co)
{
    int chl=2*k+1,chr=2*k+2;
    dat[chl]=dat[k];
    dat[chr]=dat[k];
    dat[k]=0;
}
void update(int a,int b,int co,int k,int l,int r)
{
    if(b<l||a>r) return ;
    if(a<=l&&r<=b) dat[k]=co;
    else{
        int chl=2*k+1,chr=2*k+2,mid=(l+r)/2;
        if(dat[k]) Push_Down(k,co);
        update(a,b,co,chl,l,mid);
        update(a,b,co,chr,mid+1,r);
    }
}

区间加值：
void add(int a,int b,int x,int k,int l,int r)
{
    if(a<=l&&r<=b) data[k]+=x;
    //对于不包含的情况不进行处理
    else if(l<b&&a<r){
        datb[k]+=(min(b,r)-max(a,l))*x;
        add(a,b,x,k*2+1,l,(l+r)/2);
        add(a,b,x,k*2+2,(l+r)/2,r);
    }
}

查询函数：

对于单点更新的区间查询函数：

int query(int a,int b,int k,int l,int r)
{
    if(r<=a||b<=l) return 0;
    if(a<=l&&b<=r) return dat[k];
    else{
        int chl=2*k+1,chr=2*k+2,mid=(l+r)/2;
        int v1=query(a,b,chl,l,mid);
        int v2=query(a,b,chr,mid+1,r);
        return v1+v2;
    }
}

对应区间加值的区间查询：
long long sum(int a,int b,int k,int l,int r)
{
    if(b<=l||r<=a) return 0;
    else if(a<=l&&r<=b) return data[k]*(r-l)+datb[k];
    else{
        long long res=(min(b,r)-max(a,l))*data[k];
        res+=sum(a,b,k*2+1,l,(l+r)/2);
        res+=sum(a,b,k*2+2,(l+r)/2,r);
        return res;
    }
}

线段树的查询方式根据题意可能有很多种，但是更新的方式相对单一，下面给出例题。
poj 2828
链接：http://poj.org/problem?id=2828
大致题意:给你一列数和每个数插入的位置，并且后插入的数会占据当前的位置，并且把当前位置上的数挤到下一个位置上去，问操作完所有插入操作后所得到的序列。
思路：因为每个位置必然会被最后插入此位置的数占据，所以我们可以从后往前来构造这个序列，从最后一个操作开始，对于每一个数，如果其插入的位置当前的状态为空则将此数插入到这个位置上，否则就向右寻找最近的空位置，将其插入，注意到Posi的范围是0~i-1所以这样构造的序列最后一定是符合题意的。	但是分析到这里还是不够的，再进一步分析我们会发现，向右寻找最近的空位置其本质就是把所有没空的位置挖掉，然后产生一个新的位置序列，在这个新的序列上再按插入位置的编号来找寻所在的位置，插入后再将插入位置挖去，产生一个新的位置序列。	再进一步想，
对于某个插入位置x，其实际的位置就是第x个空位置。 到了这里我们就可以想到用线段树来做了，开始的时候我将每个位置都设为1，用线段树来维护一个前n项和，对于某个插入x，我们只要找的前n项和为x的位置k即可，在插入操作完成之后再将位置k的值更新成0即可。~~~
code：
#include <iostream>
#include <cstring>
#include <cstdlib>
#include<cstdio>
#include <algorithm>
#define INF 1000000000
#define eps 1e-9
using namespace std;
typedef long long ll;
const int MAX_E=200;
const int MAX_V=100;
const int MAX_M=110;

const int MAX_N=800000;

int n,dat[2*MAX_N-1];
void init(int n_)
{
    n=1;
    while(n<n_) n*=2;
    for(int i=0;i<2*n-1;i++) dat[i]=0;
}
void update(int k,int a)
{
    k+=n-1;
    dat[k]=a;
    while(k>0){
        k=(k-1)/2;
        dat[k]=dat[k*2+1]+dat[k*2+2];
    }
}
int query(int m,int k,int l,int r)
{
    if(m==dat[k]&&k>=n-1) return k-(n-1);
    int mid;
    if(m>dat[k*2+1])   mid=query(m-dat[k*2+1],k*2+2,(l+r)/2+1,r);
    else mid=query(m,k*2+1,l,(l+r)/2);
    return mid;
}
int a[MAX_N];
struct node
{
    int p,val;
}P[MAX_N];
int main()
{
    int n;
    while(~scanf("%d",&n)){
        init(n);
        for(int i=n-1;i>=0;i--){
            scanf("%d%d",&P[i].p,&P[i].val);
            update(i,1);
        }
        for(int i=0;i<n;i++){
            int pp=query(P[i].p+1,0,0,n-1);
            a[pp]=P[i].val;
            update(pp,0);
        }
        for(int i=0;i<n;i++) printf("%d%c",a[i],i==n-1? '\n':' ');
    }
}

		未完待更新~~