P5494 【模板】线段树分裂 题解

很久之前写的题目了，写一篇题解来回忆一下。

线段树合并与分裂#

线段树是一个非常有意思的数据结构，它支持很多的操作，包括分裂与合并。

合并#

例题：P4556 [Vani有约会]雨天的尾巴 /【模板】线段树合并

首先，支持合并的操作的线段树，出于空间与时间的考虑，需要写动态开点线段树。

考虑如何合并两颗线段树。

首先会遍历到第一个节点，发现两棵线段树都有，那么就将维护的东西合并。

然后到第二个节点，同理，接着，发现第一棵线段树没有 $(1,2)$ 号节点，那么直接接上，无需遍历。

然后合并 $(3,3)$，接上 $(4,5)$，这就是大概的算法流程。

总结一下。

1. 遍历到一个节点，若有一方没有，则直接接上。

2. 否则，继续遍历，合并信息。

3. 当然，合并完后没有用的节点需要删除。

inline int merge(int p1 , int p2 , int l , int r)
{
    if(!p1 || !p2) return p1 + p2;
    t[p1].val += t[p2].val;
    if(l == r) { del(p2); return p1; }
    t[p1].l = merge(t[p1].l , t[p2].l , l , (l + r) / 2);
    t[p1].r = merge(t[p1].r , t[p2].r , (l + r) / 2 + 1 , r);
    del(p2); return p1;
}

分裂#

例题：P5494 【模板】线段树分裂

一般来讲，线段树的分裂是将前 $\text{k}$ 个节点分到一颗线段树上，其余的分裂到另一棵线段树上。

我们可以考虑一个和 $\text{FHQ treap}$ 相似的过程。

1. 若此时被分裂的线段树的左儿子子树大小大于等于 $\text{k}$，那么就可以将整个右儿子送给第二棵线段树。

2. 若左儿子子树大小还大于 $\text{k}$ 那么就要到左儿子处继续分裂。

3. 若左儿子子树大小小于 $\text{k}$ 那么就要到右儿子处继续分裂。

inline void split(int x , int &y , int k)
{
	if(!x) return; y = new_node(); int val = t[t[x].son[0]].sum;
	if(val < k) split(t[x].son[1] , t[y].son[1] , k - val);
	else swap(t[x].son[1] , t[y].son[1]);
	if(val > k) split(t[x].son[0] , t[y].son[0] , k);
	t[y].sum = t[x].sum - k , t[x].sum = k;
}

时间复杂度#

合并#

我知道的，大概有两种证明方法。

第一种是我们知道所有的节点一共有 $n\log n$ 个。

而我们每次合并都只会合并两方都有的节点，并且删掉其中之一。

故最多只会删除 $n\log n$ 次，复杂度为 $O(n\log n)$。

第二种可能只是第一种的另一个说法。

我们发现每一次合并都会有叶子节点，一句废话。

可以发现每次会需要 $O(\log n)$。

而只有 $n$ 个叶子节点，故复杂度为 $O(n\log n)$。

仔细想一想，两种都是一个原理。

分裂#

分裂的复杂度就比较好证了。

可以发现，每一次分裂的操作与查询的操作很像。

可以说与查找第 $k$ 个数简直一模一样。

故时间复杂度 $O(n\log n)$

关于此题#

总体来说，线段树的合并与分裂只要掌握思路代码实现比较简单。

最后附上此题代码。

#include <bits/stdc++.h>
#define int long long
using namespace std;

const int N = 200010;

int n, m, cnt, top, tot, stk[N * 32], root[N];

struct Tree
{
    int sum, son[2];
} t[N * 32];

inline int read()
{
    int asd = 0, qwe = 1; char zxc;
    while (!isdigit(zxc = getchar())) if (zxc == '-') qwe = -1;
    while (isdigit(zxc)) asd = asd * 10 + zxc - '0', zxc = getchar();
    return asd * qwe;
}

inline void del(int x)
{
    if (!x)
        return;
    t[x].sum = t[x].son[0] = t[x].son[1] = 0;
    stk[++top] = x;
}

inline int new_node()
{
    return (top ? stk[top--] : ++cnt);
}

inline void update(int &p, int l, int r, int k, int val)
{
    if (!p)
        p = new_node();
    t[p].sum += val;
    if (l == r)
        return;
    int mid = (l + r) / 2;
    if (mid >= k)
        update(t[p].son[0], l, mid, k, val);
    else
        update(t[p].son[1], mid + 1, r, k, val);
}

inline int merge(int x, int y)
{
    if (!x || !y)
        return x + y;
    t[x].sum += t[y].sum;
    t[x].son[0] = merge(t[x].son[0], t[y].son[0]);
    t[x].son[1] = merge(t[x].son[1], t[y].son[1]);
    del(y);
    return x;
}

inline void split(int x, int &y, int k)
{
    if (!x)
        return;
    y = new_node();
    int val = t[t[x].son[0]].sum;
    if (val < k)
        split(t[x].son[1], t[y].son[1], k - val);
    else
        swap(t[x].son[1], t[y].son[1]);
    if (val > k)
        split(t[x].son[0], t[y].son[0], k);
    t[y].sum = t[x].sum - k, t[x].sum = k;
}

inline int ask1(int p, int l, int r, int ql, int qr)
{
    if (!p || l > qr || r < ql)
        return 0;
    if (ql <= l && r <= qr)
        return t[p].sum;
    int mid = (l + r) / 2;
    return ask1(t[p].son[0], l, mid, ql, qr) + ask1(t[p].son[1], mid + 1, r, ql, qr);
}

inline int ask2(int p, int l, int r, int k)
{
    if (l == r)
        return l;
    if (t[t[p].son[0]].sum >= k)
        return ask2(t[p].son[0], l, (l + r) / 2, k);
    else
        return ask2(t[p].son[1], (l + r) / 2 + 1, r, k - t[t[p].son[0]].sum);
}

signed main()
{
    n = read(), m = read(), tot = 1;
    for (int i = 1; i <= n; i++)
    {
        int x = read();
        if (x)
            update(root[1], 1, n, i, x);
    }
    for (int i = 1; i <= m; i++)
    {
        int opt = read();
        if (opt == 0)
        {
            ++tot;
            int p = read(), x = read(), y = read(), tmp = 0;
            int k1 = ask1(root[p], 1, n, 1, y);
            int k2 = ask1(root[p], 1, n, x, y);
            split(root[p], root[tot], k1 - k2);
            split(root[tot], tmp, k2);
            root[p] = merge(root[p], tmp);
        }
        if (opt == 1)
        {
            int x = read(), y = read();
            root[x] = merge(root[x], root[y]);
        }
        if (opt == 2)
        {
            int p = read(), x = read(), q = read();
            update(root[p], 1, n, q, x);
        }
        if (opt == 3)
        {
            int p = read(), x = read(), y = read();
            printf("%lld\n", ask1(root[p], 1, n, x, y));
        }
        if (opt == 4)
        {
            int p = read(), k = read();
            if (t[root[p]].sum < k)
                puts("-1");
            else
                printf("%lld\n", ask2(root[p], 1, n, k));
        }
    }
    return 0;
}