【BZOJ3600】没有人的算术（替罪羊树+线段树）

点此看题面

大致题意： 定义任意数对\(>0\)，数对之间比大小先比第一位、后比第二位，一开始数列全为\(0\)，要求你支持\(a_k=(a_x,a_y)\)和询问区间最大值所在位置两种操作。

化数对为实数

直接记录数对显然是不现实，也不可能的。

考虑到若数对\((a,b)<(c,d),(c,d)<(e,f)\)，则\((a,b)\)必然小于\((e,f)\)，即数对之间的比大小具有传递性。

那么我们可以考虑把每个数对按其大小对应成一个实数，而实数之间的比大小就非常方便了，直接用线段树维护就可以处理询问了。

也就是说，我们只要知道如何化数对为实数，就可以解决整道题了。

替罪羊树

考虑到要把每个数对按大小对应成一个数，可以用平衡树。

具体地，就是对于每个点表示一个数对，并确定一个值域区间\([L,R]\)，设\(MID=(L+R)/2\)，则\(MID\)就是这个点代表的数对所对应的数，而这个点左儿子的值域区间就是\([L,MID]\)，右儿子的值域区间就是\([MID,R]\)。

特殊地，根节点的值域区间为\([0,10^9]\)（其实直接\([0,1]\)也问题不大，注意要开\(double\)）。

但是要注意，如果选取\(Treap,Splay\)等会旋转的平衡树，我们所维护的值域区间就会乱套，因此只能采取替罪羊树，而它在重构时可以暴力重新赋值。

（关于替罪羊树，可参考我的这篇博客）

注意到上面说到的重新赋值，也就是说，一个点对它所对应的实数可能是会发生变化的。

因此，在数对及线段树中，我们应该记录的是这个数对在平衡树中对应的节点编号，而非其具体值，在比大小时则可以通过调用得到其具体值进行比较（我一开始就因为这个调了很久）。

代码

#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 100000
#define M 500000
#define DB long double
#define RD Reg DB
#define CD Con DB&
using namespace std;
int n,a[N+5];DB p[M+5];
class FastIO
{
	private:
		#define FS 100000
		#define tc() (A==B&&(B=(A=FI)+fread(FI,1,FS,stdin),A==B)?EOF:*A++)
		#define pc(c) (C==E&&(clear(),0),*C++=c)
		#define tn (x<<3)+(x<<1)
		#define D isdigit(c=tc())
		int T;char c,*A,*B,*C,*E,FI[FS],FO[FS],S[FS];
	public:
		I FastIO() {A=B=FI,C=FO,E=FO+FS;}
		Tp I void read(Ty& x) {x=0;W(!D);W(x=tn+(c&15),D);}
		I void readc(char& x) {W(isspace(x=tc()));}
		Tp I void write(Ty x) {W(S[++T]=x%10+48,x/=10);W(T) pc(S[T--]);}
		Tp I void writeln(Con Ty& x) {write(x),pc('\n');}
		I void clear() {fwrite(FO,1,C-FO,stdout),C=FO;}
}F;
struct data
{
	int x,y;I data(CI a=0,CI b=0):x(a),y(b){}
	I bool operator < (Con data& o) Con {return p[x]!=p[o.x]?p[x]<p[o.x]:p[y]<p[o.y];}
	I bool operator == (Con data& o) Con {return x==o.x&&y==o.y;}
};
class ScapegoatTree//替罪羊树
{
	private:
		#define alpha 0.75
		#define PU(x) (O[x].Sz=O[O[x].S[0]].Sz+O[O[x].S[1]].Sz+1)
		#define Balance(x) (alpha*O[x].Sz>1.0*max(O[O[x].S[0]].Sz,O[O[x].S[1]].Sz))
		#define ReBuild(x,L,R) (cnt=0,Tr(x),SetUp(x,1,cnt,L,R))
		int rt,tot,cnt,cur[M+5];
		struct node {int Sz,S[2];data V;}O[M+5];
		I int ins(int& rt,CD L,CD R,Con data& v)//插入一个新数对，返回节点编号
		{
			if(!rt) return O[rt=++tot].V=v,p[rt]=(L+R)/2,O[rt].Sz=1,rt;if(O[rt].V==v) return rt;
			RD MID=(L+R)/2;RI t;return t=v<O[rt].V?ins(O[rt].S[0],L,MID,v):ins(O[rt].S[1],MID,R,v),PU(rt),t;
		}
		I void chk(int& rt,CD L,CD R,Con data& v)//检验是否平衡
		{
			if(!rt) return;if(!Balance(rt)) return ReBuild(rt,L,R);if(O[rt].V==v) return;
			RD MID=(L+R)/2;v<O[rt].V?chk(O[rt].S[0],L,MID,v):chk(O[rt].S[1],MID,R,v);
		}
		I void Tr(CI x) {x&&(Tr(O[x].S[0]),cur[++cnt]=x,Tr(O[x].S[1]),0);}//中序遍历，存下节点
		I void SetUp(int& rt,CI l,CI r,CD L,CD R)//重构
		{
			RI mid=l+r>>1;RD MID=(L+R)/2;p[rt=cur[mid]]=MID,//重新赋值
			l<mid?(SetUp(O[rt].S[0],l,mid-1,L,MID),0):(O[rt].S[0]=0),//处理左儿子
			r>mid?(SetUp(O[rt].S[1],mid+1,r,MID,R),0):(O[rt].S[1]=0),PU(rt);//处理右儿子
		}
	public:
		I int Ins(CI x,CI y) {RI t;data w(x,y);return t=ins(rt,0,1e9,w),chk(rt,0,1e9,w),t;}
		#undef PU
}T;
class SegmentTree//线段树
{
	private:
		#define P CI l=1,CI r=n,CI rt=1
		#define L l,mid,rt<<1
		#define R mid+1,r,rt<<1|1
		#define mp make_pair
		#define fir first
		#define sec second
		#define Max(X,Y) (p[a[X]]>=p[a[Y]]?X:Y)
		#define PU(x) (Mx[x]=Max(Mx[x<<1],Mx[x<<1|1]))
		int Mx[N<<2];
	public:
		I void Build(P)//建树
		{
			if(l==r) return (void)(Mx[rt]=l);RI mid=l+r>>1;Build(L),Build(R),PU(rt);
		}
		I void Upt(CI x,P)//修改，实际上只是刷新一下这个点到根路径上的信息
		{
			if(l==r) return;RI mid=l+r>>1;x<=mid?Upt(x,L):Upt(x,R),PU(rt);
		}
		I int Qry(CI tl,CI tr,P)//询问
		{
			if(tl<=l&&r<=tr) return Mx[rt];RI mid=l+r>>1;RI t,res=0;
			tl<=mid&&(t=Qry(tl,tr,L),res?(res=Max(res,t)):(res=t)),
			tr>mid&&(t=Qry(tl,tr,R),res?(res=Max(res,t)):(res=t));return res;
		}
}S;
int main()
{
	RI Qt,i,l,r,k;char op;F.read(n),F.read(Qt),S.Build();
	for(T.Ins(0,0),i=1;i<=n;++i) a[i]=1;//初始化
	W(Qt--) F.readc(op),F.read(l),F.read(r),//读入
		op=='C'?F.read(k),a[k]=T.Ins(a[l],a[r]),S.Upt(k):F.writeln(S.Qry(l,r));//处理
	return F.clear(),0;
}