线段树原理

线段树

线段树

简单说就是用二叉树来构造，树的每一个结点代表一条线段[L,R]，用于区间处理。
如果L=R，说明这个结点只有一个点，是叶子结点；如果L<R，说明不止一个点，左儿子[L,M]，右儿子[M+1,R]，其中M=(L+R)/2。
线段树中，如果一个节点的编号为x，那么左儿子的编号为2x，右儿子的编号为2x+1。
N个元素的线段树的高度为logN+1。

建树

普通二叉树建线段树

const int Max=10000;
struct {
    int l, r, len;//len储存这个区间下数字的个数
} tree[4*Max];//线段树空间需要
void BuildTree(int left, int right, int u)//建树
{
    tree[u].l=left;
    tree[u].r=right;
    tree[u].len=right-left+1;//更新结点u的值
    if(left==right)
        return;
    BuildTree(left,(left+right)>>1,u<<1);//递归左子树
    BuildTree(((left+right)>>1)+1,right,(u<<1)+1);//递归右子树
}

完全二叉树建立线段树

void BuildTree(int n,int last_left)//用完全二叉树建一个线段树
{
    int i;
    for(i=last_left; i<last_left+n; i++)
        tree[i]=1;//给二叉树的最后一行赋值,左边n个结点是n头牛
    while(last_left!=1)//从二叉树的最后一行倒推到根结点,根结点的值是总数
    {
        for(i=last_left/2; i<last_left; i++)
            tree[i]=tree[i*2]+tree[i*2+1];
        last_left=last_left/2;
    }
}

单点修改

模板：d为更新值，index为更新点，lr为更新范围

void update(int d,int index,int l,int r,int node){
	if(l == r) {
		tree[node] += d; // 更新方式，可以变化
		return;
	}
	int mid = (l+r) / 2;
	// push_down(node,mid-l+1,r-mid); 若既有点更新又有区间更新，需要这句话
	if(index <= mid){
		update(d,index,l,mid,node*2);
	}else{
		update(d,index,mid+1,r,node*2+1);
	}
	tree[node] = tree[node*2] + tree[node*2 + 1]; // 向上更新
}

区间修改

在线段树的基础上增加了以下操作：
区间[i,j]内的值全部加v
计算区间[l,r]的区间和
为了节省时间，采取lazy原理，即树上某一结点的区间全部在[i,j]范围内，只需要对该结点的区间值全部加v，不需要继续深入对每一个数改变；如果树上某一结点的区间有部分在[i,j]范围内，不能再用lazy，需继续深入直到全部在范围内。

建树

#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1//这里或运算即rt*2+1
void build(int l,int r,int rt)//满二叉树建树
{
    add[rt]=0;
    if(l==r)
    {
        scanf("%lld",&sum[rt]);
        return;
    }
    int mid=(l+r)>>1;
    build(lson);
    build(rson);
    push_up(rt);//向上更新区间和
}

向上更新函数与向下更新函数

向上更新函数用于把子结点的值递归到父结点，更新区间并求区间和时需要用到；向下更新函数用于碰坏lazy，更新子结点。

void push_up(int rt)//向上更新，通过当前结点rt把值递归到父结点
{
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
}
void push_down(int rt,int m)//更新rt的子结点,m为区间数字的个数
{
    if(add[rt])
    {
        add[rt<<1]+=add[rt];//左儿子累加
        add[rt<<1|1]+=add[rt];//右儿子累加
        sum[rt<<1]+=(m-(m>>1))*add[rt];//左儿子区间总和变化
        sum[rt<<1|1]+=(m>>1)*add[rt];//右儿子区间总和变化
        add[rt]=0;//取消本层标记
    }
}

区间更新

对区间[a,b]内的每一个元素加c，[l,r]为查询区间

void update(int a,int b,long long c,int l,int r,int rt)
{
    if(a<=l&&b>=r)
    {
        sum[rt]+=(r-l+1)*c;
        add[rt]+=c;
        return;
    }
    push_down(rt,r-l+1);//先向下更新
    int mid=(l+r)>>1;//分成两半继续深入
    if(a<=mid)
        update(a,b,c,lson);
    if(b>mid)
        update(a,b,c,rson);
    push_up(rt);//向上更新
}

区间查询

long long query(int a,int b,int l,int r,int rt)//区间求和
{
    if(a<=l&&b>=r)
        return sum[rt];//满足lazy,直接返回值
    push_down(rt,r-l+1);//向下更新
    int mid=(l+r)>>1;
    long long ans=0;
    if(a<=mid)
        ans+=query(a,b,lson);
    if(b>mid)
        ans+=query(a,b,rson);
    return ans;
}