[算法总结] 线段树(不会详讲)!

本篇线段树分析的是Acwing上的线段树代码

1.树的信息

这里注意 , 请开4倍空间 , 无证明
这里用结点存储区间 少了在函数那里的形参 (yxc yyds!)

struct node
{
    int l,r;
    int v;
}tr[N*4];///开4倍空间

2.针对单点操作

-pushup操作(通过子节点信息来计算父节点)

这里求的是最大值
u<<1表示 u2 即u的左儿子
u<<1|1表示 u2+1即 u的右儿子

void pushup(int u)  
{
    tr[u].v = max(tr[u << 1].v, tr[u << 1 | 1].v);
}

-建树操作

对于每个区间 我们都用Node存
如果遍历到了 [x,x]这种单点区间 返回即可
否则向两边跑

void build(int u,int l,int r)
{
    tr[u] = {l,r};
    if(l == r)
        return ;
    int mid = l+r>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
}

-查询操作

如果当前区间正好在 某个完整的区间(也就是在树上的单个区间)上 返回该点的值

否者我们就将这个区间对半分,然后再跑左右

int query(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].v;  
    int mid = tr[u].l + tr[u].r >> 1;
    int v = 0;
    if (l <= mid) v = query(u << 1, l, r);
    if (r > mid) v = max(v, query(u << 1 | 1, l, r));
    return v;
}

-单点更新

如果 当前区间是单点区间 那么直接对v赋值
否者 区间对半分,
别忘记对每个区间进行pushup更新

void modify(int u, int x, int v)
{
    if (tr[u].l == x && tr[u].r == x) tr[u].v = v;
    else
    {
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) modify(u << 1, x, v);
        else modify(u << 1 | 1, x, v);
        pushup(u);
    }
}

3.针对区间的操作

-关于lazy标记

给以当前节点为根的子树中的每一个节点,
如果当前区间在某个根节点下面,那么我们只需要给根节点打上标记即可
加上一个lazy (不包含当前自己)
加上lazy标记 可以让我们更快nlogn的查询区间

-pushup(更新父节点操作没变)

这里是求和

void pushup(int u)
{
    tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}

-建树操作(也没变)

只是多了一个赋值,同时将懒标记初始化为0

void build(int u, int l, int r)
{
	
    if (l == r) tr[u] = {l, r, w[r], 0};
    else
    {
        tr[u] = {l, r};
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

-PushDown操作

从节点往下走,同时把值传递给左右子树
本身自己的lazy变为0
这两个sum操作都是进行区间的赋值,别看怕了

void pushdown(int u)
{
    auto &root = tr[u], &left = tr[u << 1], &right = tr[u << 1 | 1];
    if (root.lazy)
    {
        left.lazy += root.lazy, left.sum += (LL)(left.r - left.l + 1) * root.lazy;
        right.lazy += root.lazy, right.sum += (LL)(right.r - right.l + 1) * root.lazy;
        root.lazy = 0;
    }
}

-查询操作(多了一个pushdown操作)

在查询的时候pushdown改变sum的值
其他基本没变

LL query(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].sum;

    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    LL sum = 0;
    if (l <= mid) sum = query(u << 1, l, r);
    if (r > mid) sum += query(u << 1 | 1, l, r);
    return sum;
}

-更新操作(区间更新)

如果正好在这个区间内
那么只需要对当前区间进行变化即可
同时给这个根节点打上lazy标记(暂时未知)
否者我们需要在分区间的之前进行pushdown
然后我们在对父节点进行pushup

void modify(int u, int l, int r, int d)
{
    if (tr[u].l >= l && tr[u].r <= r)
    {
        tr[u].sum += (LL)(tr[u].r - tr[u].l + 1) * d;
        tr[u].lazy += d;
    }
    else    // 一定要分裂
    {
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid) modify(u << 1, l, r, d);
        if (r > mid) modify(u << 1 | 1, l, r, d);
        pushup(u);
    }
}

以上两个模板

1.单点区间求最大

#include <bits/stdc++.h>
using namespace std;
const int  N =  200010;
int m,p;
struct Node
{
    int l,r;
    int v;
} tr[N*4];

void pushup(int u)
{
    tr[u].v = max(tr[u<<1].v,tr[u<<1|1].v);
}
void build(int u,int l,int r )
{
    tr[u] = {l,r};
    if(l  ==  r) return ;
    int mid  = l+r>>1;
    build(u<<1,l,mid),build(u<<1|1,mid+1,r) ;
}
int query(int u,int l,int r)
{
    if(tr[u].l >= l && tr[u].r<=r)
        return tr[u].v;

    int mid = tr[u].l+tr[u].r>>1;
    int v = 0;
    if(l<=mid) v = max(v,query(u<<1,l,r));
    if(r>mid)  v=  max(v,query(u<<1|1,l,r));
    return v;

}
void modify(int u,int x,int v)
{
    if(tr[u].l == x&&tr[u].r==x) tr[u].v = v;
    else
    {
        int mid = tr[u].l+tr[u].r>>1;
        if(x<=mid) modify(u<<1,x,v);
        else modify(u<<1|1,x,v);
        pushup(u);

    }
}
int main()
{
    int n = 0, last = 0;
    scanf("%d%d", &m, &p);
    build(1, 1, m);

    int x;
    char op[2];
    while (m -- )
    {
        scanf("%s%d", op, &x);
        if (*op == 'Q')
        {
            last = query(1, n - x + 1, n);
            printf("%d\n", last);
        }
        else
        {
            modify(1, n + 1, (last + x) % p);
            n ++ ;
        }
    }



    return 0;
}

2.求区间和

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 100010;

int n, m;
int w[N];
struct Node
{
    int l, r;
    LL sum, lazy;
}tr[N * 4];

void pushup(int u)
{
    tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}

void pushdown(int u)
{
    auto &root = tr[u], &left = tr[u << 1], &right = tr[u << 1 | 1];
    if (root.lazy)
    {
        left.lazy += root.lazy, left.sum += (LL)(left.r - left.l + 1) * root.lazy;
        right.lazy += root.lazy, right.sum += (LL)(right.r - right.l + 1) * root.lazy;
        root.lazy = 0;
    }
}

void build(int u, int l, int r)
{
    if (l == r) tr[u] = {l, r, w[r], 0};
    else
    {
        tr[u] = {l, r};
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

void modify(int u, int l, int r, int d)
{
    if (tr[u].l >= l && tr[u].r <= r)
    {
        tr[u].sum += (LL)(tr[u].r - tr[u].l + 1) * d;
        tr[u].lazy += d;
    }
    else    // 一定要分裂
    {
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid) modify(u << 1, l, r, d);
        if (r > mid) modify(u << 1 | 1, l, r, d);
        pushup(u);
    }
}

LL query(int u, int l, int r)
{
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].sum;

    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    LL sum = 0;
    if (l <= mid) sum = query(u << 1, l, r);
    if (r > mid) sum += query(u << 1 | 1, l, r);
    return sum;
}


int main()
{
    scanf("%d%d", &n, &m);

    for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);

    build(1, 1, n);

    char op[2];
    int l, r, d;

    while (m -- )
    {
        scanf("%s%d%d", op, &l, &r);
        if (*op == 'C')
        {
            scanf("%d", &d);
            modify(1, l, r, d);
        }
        else printf("%lld\n", query(1, l, r));
    }

    return 0;
}