线段树学习笔记

引例

给你n个数，m次操作，操作有两种，
1.询问区间[l，r]的和；2.让[l，r]中的所有数加上一个数
如果n,m≤1e6
暴力必然T

线段树的模型：

线段树是一种二叉树，它的每一个节点代表一个区间[a，b]，它的叶节点代表单位区间[a,a]，即点a。

对一个非叶节点，设它的编号为x，区间为[a，b]，那么它的左儿子的编号就是（2x）,区间是[a,(a+b)/2]；它的右儿子的编号是（2x+1）,区间是[(a+b)/2+1,b]

线段树的实现

线段树的实现通常分为以下几个函数：
build()//建立线段树
update()//更新线段树（区间更新或者单点更新）
query()//查询(区间和、区间最值)
pushdown()//向下延时更新

建树

void build(int l, int r, int rt)//建树
{
    if(l == r)//当前点是叶子节点
    {
        sum[rt] = a[l]; 
        return;
    }
    int mid = (l + r) / 2;
    build(l, mid, rt * 2);//建左儿子
    build(mid + 1, r, rt * 2 + 1);//建右儿子
    sum[rt] = sum[rt * 2] + sum[rt * 2 + 1]);//当前节点所表示区间元素之和
}

单点更新

    void update(int p, int v, int l, int r, int rt)//单点更新
    {
        if(l== r)//当前点是所需更新点
        {
            sum[rt] += v;	
            return;
        }
        int mid = (l + r) / 2;
        if (p <= mid)//更新左儿子
            update(p, v, l, mid, rt * 2);
        if (p > mid)//更新右儿子
            update(p, v, mid+1, r, rt * 2 + 1);
        sum[rt] = sum[rt * 2] + sum[rt * 2 + 1];
    }

区间更新

void update(int l1, int r1, int v, int l, int r, int rt)//区间更新
{
    if(l1 <= l && r <= r1)//当前点是需要更新区间的子区间
    {
        sum[rt] += v * (r - l + 1);
        lazy[rt] += v;	
        return;
    }
    int mid = (l + r) / 2;
    if (l1 <= mid)//更新左儿子
        update(l1, r1, v, l, mid, rt * 2);
    if (r1 > mid)//更新右儿子
        update(l1, r1, v, mid+1, r, rt * 2 + 1);
    sum[rt] = sum[rt * 2] + sum[rt * 2 + 1];
}

询问区间和

int query(int l1, int r1, int l, int r, int rt)//询问区间和
{
    if(l1 <= l && r <= r1)//如果当前区间是询问区间的子区间
        return sum[rt];
    int mid = (l + r) / 2;
    int ret = 0;
    pushdown(mid - l + 1, r - mid, rt);//更新
    if (l1 <= mid) //询问区间与左儿子有交集
        ret += query(l1, r1, l, mid,rt * 2);
    if (r1 > mid) //询问区间与右儿子有交集
        ret += query(l1, r1, mid + 1, r, rt * 2 + 1);
    return ret;
}

向下延时更新

void pushdown(int l, int r, int rt)
{
    if(lazy[rt])//如果有延时标记
    {
        lazy[rt * 2] += lazy[rt]; //标记传递
        lazy[rt * 2 + 1] += lazy[rt]; //标记传递
        lazy[rt] = 0;
        sum[rt * 2] += l * lazy[rt * 2]; //左儿子之和更新
        sum[rt * 2 + 1] += r * lazy[rt * 2 + 1]; //右儿子之和更新
    }
}

注意

1.线段树要开四倍大小空间
2.建树复杂度为o(nlogn)每次更新、询问的复杂度均为o(logn)
（最坏情况是从根节点一直更新到叶子节点）

拓展

如果把引例修改一下，
1.把操作2改成单点修改：
可以用树状数组（空间复杂度o(n)，每次修改和查询时间复杂度o(logn)）（主要是代码量会减少）
2.把操作改成求[l,r]区间最大值，操作次数1e7：
使用ST表（空间复杂度o（nlogn），每次查询时间复杂度o(1)）