(因为没有认证,所以这道题就由Froggy上传)
线段树分裂用到的地方确实并不多,luogu上以前也没有这道模板题,所以就出了一道,实在是想不出怎么出模板了,所以这道题可能可以用一些其他的算法水过去.

前置芝士

1. 线段树: 本题中用到的是权值线段树(查询每个数在序列中出现的次数,序列中第k大的数等操作).
2. 线段树合并: 为了增加一下码量才放上的.

线段树分裂

既然是模板题,这个自然才是重点.
以下这样一颗线段树:

需要将橙色线段覆盖的部分分裂出来,需要建一颗新的树,当一个节点所代表的区间与需要分裂的区间有交时需要开一个新的节点(绿色部分),原来的树中需要将那些整个被分裂的部分直接接到新的树下面,并且将于原来的树的边断开(红色部分),可以发现被断开的边最多只会有\(\log_2N\)条,所以最终每次分裂的时间复杂度就是\(\log_2N\)(证明方法与区间修改为\(N\log_2N\)相同).

代码

#include<bits/stdc++.h>
#define rap(i,first,last) for(int i=first;i<=last;++i)
//线段树标准define
#define Lson (tree[now].lson)
#define Rson (tree[now].rson)
#define Middle ((left+right)>>1)
#define Left Lson,left,Middle
#define Right Rson,Middle+1,right
#define Now nowleft,nowright
using namespace std;
const int maxN=6e5+7;//因为有分裂,需要大一点的空间
int N,M;
struct Tree//线段树中每一个节点
{
    int lson,rson;//动态开点,记录左右儿子
    long long sum;//区间和
}tree[maxN*4];
int cnt=0;
//一下是一个空间回收,可以将在线段树合并后没有用的点回收,更好地利用空间
int tot=0;//删掉的节点的个数
int rubbish[maxN*4];//用来放删掉的节点的编号
void Del(int &now)//删除一个节点
{
    tree[now].lson=tree[now].rson=tree[now].sum=0;//先清空
    rubbish[++tot]=now;//放入垃圾桶
    now=0;
}
int New()//得到一个新的节点
{
    if(tot)return rubbish[tot--];//垃圾桶不是空的就从垃圾桶上面拿一个
    return ++cnt;//垃圾桶是空的就拿一个全新的节点
}
//空间回收代码结束
int arr[maxN];//开始读入的数组
void PushUp(int now)//合并信息
{
    tree[now].sum=tree[Lson].sum+tree[Rson].sum;
}
void Build(int &now,int left=1,int right=N)//建树
{
    if(!now)now=New();//得到一个新节点
    if(left==right)
    {
        tree[now].sum=arr[left];//叶节点直接赋值
        return;
    }
    Build(Left);//建左子树
    Build(Right);//建右子树
    PushUp(now);//合并信息
}
void Merge(int &tree1,int &tree2,int left=1,int right=N)//线段树合并,将tree2合并到tree1上
{
    if(!tree1||!tree2)//如果当前这棵树只有其中一颗树有就可以直接赋值
    {
        tree1+=tree2;
        return;
    }
    if(left==right)//叶节点就直接合并
    {
        tree[tree1].sum+=tree[tree2].sum;
        Del(tree2);//删掉tree2
        return;
    }
    Merge(tree[tree1].lson,tree[tree2].lson,left,Middle);//继续合并
    Merge(tree[tree1].rson,tree[tree2].rson,Middle+1,right);
    Del(tree2);//删掉tree2
    PushUp(tree1);//合并信息
}
void Split(int &tree1,int &tree2,int nowleft,int nowright,int left=1,int right=N)//线段树分裂(将tree1中nowleft~nowright部分分裂到tree2中)
{
    if(right<nowleft||nowright<left)return;//没有被覆盖就直接返回
    if(!tree1)return;//如果tree1没有自然也没有用了
    if(nowleft<=left&&right<=nowright)//被完全覆盖时
    {
        tree2=tree1;
        tree1=0;//把边断开
        return;
    }
    if(!tree2)tree2=New();//得到一个新节点
    Split(tree[tree1].lson,tree[tree2].lson,Now,left,Middle);//左右子树继续分裂
    Split(tree[tree1].rson,tree[tree2].rson,Now,Middle+1,right);
    PushUp(tree1);//合并两数信息
    PushUp(tree2);
}
void UpData(int num,int add,int &now,int left=1,int right=N)//单点修改(不多讲)
{
    if(num<left||num>right)return;
    if(!now)now=New();
    if(left==right)
    {
        tree[now].sum+=add;
        return;
    }
    UpData(num,add,Left);
    UpData(num,add,Right);
    PushUp(now);
}
long long QuerySum(int nowleft,int nowright,int now,int left=1,int right=N)//查询区间和(不多讲)
{
    if(nowright<left||right<nowleft)return 0;
    if(!now)return 0;
    if(nowleft<=left&&right<=nowright)
    {
        return tree[now].sum;
    }
    return QuerySum(Now,Left)+QuerySum(Now,Right);
}
int QueryKth(long long k,int now,int left=1,int right=N)//查询区间第k大(不多讲)
{
    if(k<=0)return -1;
    if(left==right)return left;
    if(tree[Lson].sum>=k)return QueryKth(k,Left);
    return QueryKth(k-tree[Lson].sum,Right);
}
int root[maxN];//记录每一个序列的线段树的根节点
int cnttree=1;//序列的编号
int main()
{
    scanf("%d%d",&N,&M);
    rap(i,1,N)scanf("%d",&arr[i]);
    Build(root[1]);//以root[1]建树
    int check,p,t,x,y,k,q,kth;
    rap(i,1,M)
    {
        scanf("%d",&check);
        if(check==0)
        {
            scanf("%d%d%d",&p,&x,&y);
            Split(root[p],root[++cnttree]/*建一颗新树*/,x,y);//分裂
        }
        if(check==1)
        {
            scanf("%d%d",&p,&t);
            Merge(root[p],root[t]);//合并
        }
        if(check==2)
        {
            scanf("%d%d%d",&p,&x,&q);
            UpData(q,x,root[p]);//修改
        }
        if(check==3)
        {
            scanf("%d%d%d",&p,&x,&y);
            printf("%lld\n",QuerySum(x,y,root[p]));//区间和
        }
        if(check==4)
        {
            scanf("%d%d",&p,&k);
            if(QuerySum(1,N,root[p])<k)kth=-1;//区间和都没有k自然是不会有第k大了
            else
            kth=QueryKth(k,root[p]);
            printf("%d\n",kth);
        }
    }
}

原文地址：https://www.cnblogs.com/Sxy_Limit/p/12233746.html