线段树的分裂与合并

前置知识点：线段树，动态开点

对于一些题目，可能两颗线段树要用到各自的节点信息，这时候线段树合并和分裂就可以完美的解决这类问题，比如说x树没有y中的一些节点，就可以直接利用y的节点信息，合并两颗线段树的时间复杂度是mlogm的。

分裂是将一颗线段树的一部分区间拿出来单独作为一颗线段树，拿掉这些区间后原线段树不再拥有这些节点。

 

 

主要操作1：spilt（分裂）

int spilt(int &q, int l, int r, int x, int y) //x, y是要拿出来的区间，l，r是线段树维护的区间
//
{
    int q = ++ idx;
    if(x <= l && y >= r)
    {
        tr[q] = tr[p]; //如果需要修改的区间覆盖当前维护的区间，让新的线段树指向该节点。
        p = 0;//把原线段树的节点删除
        return q;
    }
    
    int mid = l + r >> 1;
    if(x <= mid) tr[q].l = spilt(tr[p].l, l, mid);
    if(y > mid) tr[q].r = spilt(tr[p].r, mid + 1, r);
    return q;
}

void merge(int &x, int &y)//将y树合并到x树去
{
    if(!x || !y) x |= y; 
    // 如果x的当前节点不存在或者y的当前节点不存在，x|= y是将x树的当前指针指向x树或y树中存在的
    //节点，如果x树中当前节点存在就指向x树的当前节点，否则是y树中存在，指向y树中的节点。
    //注意：如果是y树中的节点存在，操作之后x的指针和y的指针都指向当前节点，如果x树中修改这个节点，y的树的结构也会发生变化
    //这样用的话就要保证y树不在复用，否则可能会出错
    else
    {
        tr[x].sz += tr[y].sz;//维护题目中需要维护的信息
        merge(tr[x].l, tr[y].l);
        merge(tr[x].r, tr[y].r);
        //向下递归左右子树的合并
    }
}

下面是洛谷的模板题：https://www.luogu.com.cn/problem/P5494

每次执行第一个操作时得到的线段树我们称为一个新的版本。

这里查询操作是区间的数的个数，所以要维护树的大小，因为树的值在1~n之间，所以可以将线段树的下标当成权值，就不需要另外维护权值了。

op == 1: 将第p个版本的线段树的x，y区间分离出来。

op == 2:将第t个版本的线段树合并到第p个版本的线段树内，并清空线段树t，这说明第t个版本的线段树不在复用。

op == 3:查找第p个版本线段树的权值在x~y之间的数的个数，就是查询线段树的下标在x~y的数的个数，线段树的基本区间查询

op == 4:查询第p个版本内第k小数

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;

typedef long long LL;
const int N = 200010, mod = 998244353;

struct Node{
    int l, r;
    LL sz;
}tr[N * 40];
int root[N * 2], idx;
int w[N];

void pushup(int u)
{
    tr[u].sz = tr[tr[u].l].sz + tr[tr[u].r].sz;
}

void modify(int &p, int l, int r, int pos, int x)
{
    if(!p) p = ++ idx;
    tr[p].sz += x;
    if(l == r) return;
    int mid = l + r >> 1;
    if(pos <= mid) modify(tr[p].l, l, mid, pos, x);
    else modify(tr[p].r, mid + 1, r, pos, x);
}

int spilt(int &p, int l, int r, int x, int y)
{
    int q = ++ idx;
    if(x <= l && y >= r)
    {
        tr[q] = tr[p];
        p = 0;
    }
    else
    {
        int mid = l + r >> 1;
        if(x <= mid) tr[q].l = spilt(tr[p].l, l, mid, x, y);
        if(y > mid) tr[q].r = spilt(tr[p].r, mid + 1, r, x, y);
        pushup(q), pushup(p);
    }
    return q;
}

void merge(int &q, int p)
{
    if(!(q && p)) q |= p;
    else
    {
        tr[q].sz += tr[p].sz;
        merge(tr[q].l, tr[p].l);
        merge(tr[q].r, tr[p].r);
    }
}

LL query(int p, int l, int r, int x, int y)
{
    if(x <= l && y >= r) return tr[p].sz;
    int mid = l + r >> 1;
    LL res = 0;
    if(x <= mid) res += query(tr[p].l, l, mid, x, y);
    if(y > mid) res += query(tr[p].r, mid + 1, r, x, y);
    return res;
}

int get_k(int p, int l, int r, int k) 查找第k小数
{
    if(l == r) return r;
    int mid = l + r >> 1;
    if(k <= tr[tr[p].l].sz) return get_k(tr[p].l, l, mid, k); 
    else return get_k(tr[p].r, mid + 1, r, k - tr[tr[p].l].sz);
　　//如果前半个区间的数多于k个，那么第k小数在前半个区间，直接递归到前半个区间
　　//否则在后半个区间，递归后半个区间同时要减去前半个区间的树的大小再加1

}

int main()
{
    int n, m;
    cin >> n >> m;
    for(int i = 1; i <= n; i ++ ) 
    {
        int x;
        cin >> x;
        modify(root[1], 1, n, i, x);
    }

    int cnt = 1;
    while(m -- )
    {
        int op;
        cin >> op;
        if(op == 0)
        {
            int p, x, y;
            cin >> p >> x >> y;
            root[ ++ cnt] = spilt(root[p], 1, n, x, y);
        }
        else if(op == 1)
        {
            int p, t;
            cin >> p >> t;
            merge(root[p], root[t]);
        }
        else if(op == 2)
        {
            int p, x, q;
            cin >> p >> x >> q;
            modify(root[p], 1, n, q, x);
        }
        else if(op == 3)
        {
            int p, x, y;
            cin >> p >> x >> y;
            cout << query(root[p], 1, n, x, y) << endl;
        }
        else 
        {
            int p, k;
            cin >> p >> k;
            if(tr[root[p]].sz < k) puts("-1");
            else cout << get_k(root[p], 1, n, k) << endl;
        }
    }
    
    return 0;
}