线段树模板

旋的博客

已于 2024-04-12 23:11:22 修改

阅读量72

点赞数 1

文章标签：算法数据结构

于 2023-10-02 20:51:28 首次发布

本文链接：https://blog.csdn.net/weixin_62598521/article/details/133499873

版权

当我们需要修改一个数组单点/区间的值，或查询数组区间 [l, r] 内的最大值/最小值时，我们就可以选择线段树这种数据结构来优化修改/查询这两种操作的时间复杂度

注意：l+r>>1等价于(l+r)>>1

静态线段树（单点修改加查询区间最值）

第一种模板只适合单点修改的题目，每次修改都传递到树的子节点。对于区间修改则不合适，同时，由于数组大小事先申明好，其点数也有上限。

const int MIN_INT = 0x80000000, N = 5e5 + 2;
struct Node {
    int l, r;
    int v;
}tr[N<<2]; 
// 线段树的空间往往不会被充分利用，所以需要开大空间避免越界，一般来说开成N的4倍比较保险

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

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

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


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 res = MIN_INT; 
    if(mid >= L) 
        res = max(res, query(u<<1, L, R));
    if(mid < R)
        res = max(res, query(u<<1|1, L, R));
    return res;
}

静态线段树（单点修改加求区间和最大的连续序列，注意此时区间中包含负元素）

const int N = 5e5 + 2;
struct Node {
    int l,r;
    ll sum, maxl, maxr, ans;//这段序列的总和,以左端点为头的 和最大的连续序列,以右端点为尾的 和最大的连续序列，这段序列中的最大的连续序列
}tr[N<<2]; 
// 线段树的空间往往不会被充分利用，所以需要开大空间避免越界，一般来说开成N的4倍比较保险

void inline pushup(int u) {
	tr[u].sum = tr[u<<1].sum + tr[u<<1|1].sum;
    tr[u].maxl = max(tr[u<<1].maxl, tr[u<<1].sum + tr[u<<1|1].maxl);
    tr[u].maxr = max(tr[u<<1|1].maxr, tr[u<<1|1].sum + tr[u<<1].maxr);
    tr[u].ans = max(max(tr[u<<1].ans, tr[u<<1|1].ans), tr[u<<1].maxr + tr[u<<1|1].maxl);
}

void build(int u, int l, int r) {
    tr[u].l = l, tr[u].r = r;
    if (l == r) {
        cin >> tr[u].sum;
        tr[u].maxl = tr[u].maxr = tr[u].ans = tr[u].sum;
        return;
    }
    int mid = tr[u].l + tr[u].r >> 1;
    build(u<<1, l, mid);
    build(u<<1|1, mid+1, r);
    pushup(u);
}

void modify(int u, int x, int k) {
    if(tr[u].l == tr[u].r) {
        tr[u].maxl = tr[u].maxr = tr[u].ans = tr[u].sum = k;
        return;
    }
    int mid = tr[u].l + tr[u].r >> 1;
    if(x <= mid) {
        modify(u<<1, x, k);
    } else {
        modify(u<<1|1, x, k);
    }
    pushup(u);
}


Node query(int u, int L, int R) {//询问函数，因为每次返回的maxleft等值不一定是左右儿子的数据，所以要返回一个结构体
    if(L <= tr[u].l && tr[u].r <= R) return tr[u];
    int mid = tr[u].l + tr[u].r >> 1;
    if(mid >= R) return query(u<<1, L, R);
    else {
        if(L > mid) return query(u<<1|1, L, R);//如果访问的区间全在右儿子里，也直接return
        else {//否则就左右儿子都访问，然后合并区间
            Node t, a = query(u<<1, L, R), b = query(u<<1|1, L, R);
            t.maxl = max(a.maxl, a.sum + b.maxl);//做类似的合并区间
            t.maxr = max(b.maxr, a.maxr + b.sum);
            t.ans = max(max(a.ans, b.ans), a.maxr + b.maxl);
            return t;//返回合并后的区间
        }
    }
}

静态线段树+懒标记（用于求区间最值）

假设我们将上面问题的操作一改为将某个区间的所有元素的值加上 k，那么该如何操作？
我们可以根据上面的查询操作来进行类似的思考，将修改区间 [l, r] 转化为修改线段树上的节点信息，但如果我们对区间 [l, r] 的每个值都进行单点修改，显然效率并不高，我们会发现其实我们修改某个节点所维护的区间时，其实不一定需要对其子节点所维护的区间也进行修改，因为我们并不一定会用上其子节点的信息。
于是这里我们引入懒标记的概念，我们给要修改的区间打上一个懒标记，这样就不用再去修改其子节点所维护的的区间，只有当我们需要使用其子节点所维护区间的信息时，再将懒标记下传更新即可。这样只有我们就可以满足用到哪一个节点就更新哪一个节点，避免了大量无意义的操作，极大提升了修改的效率。

const int INF = 0x7fffffff, N = 1E5 + 2;
struct node {
    int l, r;
    ll v = 0, tag = 0;
}tr[N<<2];

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

vector<int> a(1e5 + 5);
void build(int u, int l, int r) {
    tr[u].l = l, tr[u].r = r;
    tr[u].tag = 0, tr[u].v = -INF;
    if(l == r) {
        tr[u].v = a[l];
        return;
    }
    int mid = tr[u].l + tr[u].r >> 1;
    build(u<<1, l, mid);
    build(u<<1|1, mid+1, r);
    pushup(u);
}

void update(int u, int L, int R, int k) {
    if(L <= tr[u].l && R >= tr[u].r) {
        tr[u].tag += k;
        tr[u].v += k;
        return;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if(L <= mid) 
        update(u<<1, L, R, k);
    if(R > mid) 
        update(u<<1|1, L, R, k);
    pushup(u);
}

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

另一种静态线段树+懒标记（用于求区间和）

const int N = 1E5 + 2;
struct node {
    int l, r;
    ll v = 0, tag = 0;
}tr[N<<2];

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

void pushdown(int u) {
    tr[u<<1].tag += tr[u].tag;
    tr[u<<1].v += tr[u].tag * (tr[u<<1].r - tr[u<<1].l + 1);
    tr[u<<1|1].tag += tr[u].tag;
    tr[u<<1|1].v += tr[u].tag * (tr[u<<1|1].r - tr[u<<1|1].l + 1);
    tr[u].tag = 0;
}

vector<int> a(1e5 + 5);
void build(int u, int l, int r) {
    tr[u].l = l, tr[u].r = r;
    if(l == r) {
        tr[u].v = a[l];
        return;
    }
    int mid = tr[u].l + tr[u].r >> 1;
    build(u<<1, l, mid);
    build(u<<1|1, mid+1, r);
    pushup(u);
}

void update(int u, int L, int R, int k) {
    if(L <= tr[u].l && R >= tr[u].r) {
        tr[u].v += k * (tr[u].r - tr[u].l + 1);
        tr[u].tag += k;
        return;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if(L <= mid) 
        update(u<<1, L, R, k);
    if(R > mid) 
        update(u<<1|1, L, R, k);
    pushup(u);
}

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

加入区间乘法操作的静态线段树+懒标记

可用操作：

将某区间每一个数乘上 x；
将某区间每一个数加上 x；
求出某区间每一个数的和。

const int N = 1E5 + 2;
ll mod;
struct node {
    int l, r;
    ll v = 0, add = 0, mul = 1;
}tr[N<<2];

void inline pushup(int u) {
    tr[u].v = (tr[u<<1].v + tr[u<<1|1].v) % mod;
}

void pushdown(int u) {
    tr[u<<1].v = (tr[u].mul * tr[u<<1].v % mod + (tr[u<<1].r - tr[u<<1].l + 1) * tr[u].add % mod) % mod;
    tr[u<<1|1].v = (tr[u].mul * tr[u<<1|1].v % mod + (tr[u<<1|1].r - tr[u<<1|1].l + 1) * tr[u].add % mod) % mod;

    tr[u<<1].mul = tr[u<<1].mul * tr[u].mul % mod;
    tr[u<<1].add = (tr[u<<1].add * tr[u].mul % mod + tr[u].add) % mod;
    tr[u<<1|1].mul = tr[u<<1|1].mul * tr[u].mul % mod;
    tr[u<<1|1].add = (tr[u<<1|1].add * tr[u].mul % mod + tr[u].add) % mod;
    
    tr[u].add = 0;
    tr[u].mul = 1;
}

vector<int> a(1e5 + 5);
void build(int u, int l, int r) {
    tr[u].l = l, tr[u].r = r;
    if(l == r) {
        tr[u].v = a[l] % mod;
        return;
    }
    int mid = l + r >> 1;
    build(u<<1, l, mid);
    build(u<<1|1, mid+1, r);
    pushup(u);
}

void mul(int u, int L, int R, int k) {
    if(L <= tr[u].l && R >= tr[u].r) {
        tr[u].v = tr[u].v * k % mod;
        tr[u].mul = tr[u].mul * k % mod;
        tr[u].add = tr[u].add * k % mod;
        return;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r>>1;
    if(L <= mid) 
        mul(u<<1, L, R, k);
    if(R > mid) 
        mul(u<<1|1, L, R, k);
    pushup(u);
}

void add(int u, int L, int R, int k) {
    if(L <= tr[u].l && R >= tr[u].r) {
        tr[u].v = (tr[u].v + k * (tr[u].r - tr[u].l + 1) % mod) % mod;
        tr[u].add = (tr[u].add + k) % mod;
        return;
    }
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    if(L <= mid) 
        add(u<<1, L, R, k);
    if(R > mid) 
        add(u<<1|1, L, R, k);
    pushup(u);
}

ll query(int u, int L, int R) {
    if (L <= tr[u].l && R >= tr[u].r) 
        return tr[u].v;
    pushdown(u);
    int mid = tr[u].l + tr[u].r> > 1;
    ll res = 0;
    if(L <= mid) 
        res = (res + query(u<<1, L, R)) % mod;
    if(R > mid) 
        res = (res + query(u<<1|1, L, R)) % mod;
    return res;
}