[OI] 珂朵莉树

对于一个序列，它有较多重复元素，并且题目需要维护区间修改，维护区间信息，维护整块值域信息的，那么就可以考虑珂朵莉树解决.

主要思想

珂朵莉树将全部相同的颜色块压缩为一组，如对于下述序列：

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;
		}
	}
}