对于一个序列，它有较多重复元素，并且题目需要维护区间修改，维护区间信息，维护整块值域信息的，那么就可以考虑珂朵莉树解决.
主要思想
珂朵莉树将全部相同的颜色块压缩为一组，如对于下述序列：
1 1 1 2 3 4 4 4 4
珂朵莉树铺平后即可以变为这样：
{1,3,1} {4,4,2} {5,5,3} {6,9,4}
其中的三元组，每一个三元组描述了一个区间，第一个数表示区间左端点，第二个数表示区间右端点，第三个点表示区间的值.
这样做可以降低区间操作的均摊复杂度，从而在部分数据下表现出较高的效率.
珂朵莉树内部使用 set 实现插入，查找与删除. 对于插入操作，一般来说区间修改操作复杂度是最优的，仅需要分裂并删除部分旁边区块，再整段插入即可，其他的插入操作思想与分块大同小异.
删除操作则是先寻找后分裂，并直接删除即可.
分裂操作的实质就是将几个段分成多个段，先删除原节点，再插入子区间节点.
主要操作
珂朵莉树的大部分操作与分块类似，只不过拥有特殊的块长和性质.
分裂
目标：分裂 \(x\) 所在的区间，返回左区间的首迭代器
这里要注意的是，如果你在其他操作中用到了分裂，一定要先获取右节点迭代器再获取左节点迭代器，否则可能会出现左区间在右区间修改时被修改，导致左迭代器失效 RE 的问题.
对于分裂函数内部，请保证在 Split 之前要有值，lower_bound 对空容器查找会 RE.
auto split(int x){
auto it=odt.lower_bound({x,0,0});
if(it!=odt.end() and it->l==x) return it;
it--;
node u=*it;
odt.erase(it);
odt.insert({u.l,x-1,u.v});
return odt.insert({x,u.r,u.v}).first;
}
铺平（区间修改）
void assign(int l,int r,int v){
auto itr=split(r+1),itl=split(l);
odt.erase(itl,itr);
odt.insert({l,r,v});
}
其他操作直接用迭代器暴力扫就行了，基本都一样，这里用查找排名来做例子.
查询排名
目标：查询 \([l,r]\) 内排名为 \(x\) 的数.
思路：爆扫，统计 \(cnt\)
int rank(int l,int r,int x){
auto itr=split(r+1),itl=split(l);
struct rank{
int v,cnt;
bool operator <(const rank &A)const{
return v<A.v;
}
};
vector<rank>v;
for(auto it=itl;it!=itr;++it){
v.push_back({it->v,it->r-it->l+1});
}
sort(v.begin(),v.end());
int i;for(i=0;i<=(int)v.size()-1;++i){
if(v[i].cnt<x){
x-=v[i].cnt;
}
else{
break;
}
}
return v[i].v;
}
CF896C Willem, Chtholly and Seniorious
#include<bits/stdc++.h>
using namespace std;
#define int long long
int n;
int power(int n,int k,int p){
int ans=1,base=n;
while(k){
if(k&1){
ans=ans%p*base%p;
}
base=base%p*base%p;
k>>=1;
}
return ans;
}
class odt{
private:
struct node{
int l,r;
mutable int v;
bool operator <(const node &A)const{
return l<A.l;
}
};
set<node>odt;
public:
set<node>&self(){
return odt;
}
auto split(int x){
auto it=odt.lower_bound({x,0,0});
if(it!=odt.end() and it->l==x) return it;
it--;
node u=*it;
odt.erase(it);
odt.insert({u.l,x-1,u.v});
return odt.insert({x,u.r,u.v}).first;
}
void assign(int l,int r,int v){
auto itr=split(r+1),itl=split(l);
odt.erase(itl,itr);
odt.insert({l,r,v});
}
void add(int l,int r,int v){
auto itr=split(r+1),itl=split(l);
for(auto it=itl;it!=itr;++it){
it->v+=v;
}
}
int rank(int l,int r,int x){
auto itr=split(r+1),itl=split(l);
struct rank{
int v,cnt;
bool operator <(const rank &A)const{
return v<A.v;
}
};
vector<rank>v;
for(auto it=itl;it!=itr;++it){
v.push_back({it->v,it->r-it->l+1});
}
sort(v.begin(),v.end());
int i;for(i=0;i<=(int)v.size()-1;++i){
if(v[i].cnt<x){
x-=v[i].cnt;
}
else{
break;
}
}
return v[i].v;
}
int pow(int l,int r,int x,int y){
auto itr=split(r+1),itl=split(l);
int ans=0;
for(auto it=itl;it!=itr;++it){
ans=(ans+(it->r-it->l+1)%y*power(it->v,x,y))%y;
}
return ans;
}
};
odt tree;
int m,seed,vmax;
int Rand(){
int ret=seed;
seed=(seed*7+13)%1000000007;
return ret;
}
int a[100001];
signed main(){
cin>>n>>m>>seed>>vmax;
for(int i=1;i<=n;++i){
a[i]=Rand()%vmax+1;
tree.self().insert({i,i,a[i]});
}
for(int i=1;i<=m;++i){
int op=Rand()%4+1,l=Rand()%n+1,r=Rand()%n+1;
if(l>r) swap(l,r);
if(op==1){
int x=Rand()%vmax+1;
tree.add(l,r,x);
}
if(op==2){
int x=Rand()%vmax+1;
tree.assign(l,r,x);
}
if(op==3){
int x=Rand()%(r-l+1)+1;
cout<<tree.rank(l,r,x)<<endl;
}
if(op==4){
int x=Rand()%vmax+1,y=Rand()%vmax+1;
cout<<tree.pow(l,r,x,y)<<endl;
}
}
}