bzoj 3600 - 没有人的算术

Description

blablabla
开个脑洞：
题目讲了两页跟圣经有关的东东
替罪羊的名字又来自圣经
所以这题是替罪羊

Analysis

第二问求区间最大值用线段树就可以搞定
难度在第一问
不难想到合并时double乱搞搞出一个代表它的大小作为映射
然后当然会爆精度-.-

Solution

1.不难发现，对于将x,y合并成(x,y)的操作中
我们把题目中(l,r)稍微改成(rk[l],rk[r])
x的排名和y的排名都是已知的，所以能很快的找到(x,y)应该排第几
这就是平衡树了
2.但是，这样排名还是难以控制
我们可以在一个点上加上一个控制区域
root控制区域为(l,r)
lc[root]控制(0,mid-1),rc[root]控制(mid+1,r)
root映射到得相对大小就是mid
3.但是，有几个问题：
①一旋转这些控制区间就乱套了
②深度大了跟暴力double是一个样的
那我们就用替罪羊树的优美性质，保持重量平衡，且重构时才修改映射
4.但是，因为排名会变，把(l,r)转化成(rk[l],rk[r])存储是不现实的，改为存(pos[l],pos[r])，pos[l]指向替罪羊中的一个点，rk[pos[l]]才是排名

Notice

1.替罪羊的 深度，字数大小 都是均摊log的
2.算映射mid时小心l+r爆炸
3.重构时虽然映射变了，但其中的相对大小关系不变，是不用修改线段树的

Code

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cctype>
#include <algorithm>
using namespace std;
typedef long long LL;
typedef double db;
const int M=500007;
const db alpha=0.75;
const LL INF=9223372036854775807;

inline int rd(){
	int x=0;bool f=1;char c=getchar();
	for(;!isdigit(c);c=getchar()) if(c=='-')f=0;
	for(;isdigit(c);c=getchar()) x=x*10+c-48;
	return f?x:-x;
}

int n,m;
char s[7];

int pos[M];//pos[i]表示a[i]对应的treap中节点
LL rk[M];//treap中节点映射得到的一个排名

struct node{
	int x,y;
	node(int xx=0,int yy=0){x=xx;y=yy;}
};
bool operator ==(node x,node y){return rk[x.x]==rk[y.x]&&rk[x.y]==rk[y.y];}
bool operator < (node x,node y){return rk[x.x]<rk[y.x]||(rk[x.x]==rk[y.x]&&rk[x.y]<rk[y.y]);}

struct ScapeGt{
	node val[M];//用于treap比较大小
	int lc[M],rc[M];
	int sz[M];
	int root,tot;
	int *sgt;
	LL ssl,ssr;
	int que[M],tque;

	bool isbad(int x){
		return (db)sz[x]*alpha<(db)max(sz[lc[x]],sz[rc[x]]);
	}

	void pushup(int x){
		sz[x]=1+sz[lc[x]]+sz[rc[x]];
	}

	void dfs(int x){
		if(lc[x]) dfs(lc[x]);
		que[++tque]=x;
		if(rc[x]) dfs(rc[x]);
	}

	int build(int l,int r,LL sl,LL sr){
		if(l>r) return 0;
		int mid=l+r>>1;
		LL smid=sl+(sr-sl)/2;
		int x=que[mid];
		sz[x]=1;
		rk[x]=smid;
		lc[x]=build(l,mid-1,sl,smid-1);
		rc[x]=build(mid+1,r,smid+1,sr);
		pushup(x);
		return x;
	}

	void rebuild(int *x,LL l,LL r){
		tque=0;
		dfs(*x);
		*x=build(1,tque,l,r);
	}

	int insert(int &x,node d,LL l,LL r){
		LL mid=l+(r-l)/2;
		if(!x){
			x=++tot;
			val[x]=d;
			sz[x]=1;
			lc[x]=rc[x]=0;
			rk[x]=mid;
			return x;
		}
		if(val[x]==d) return x;
		int tp;
		if(d<val[x]) tp=insert(lc[x],d,l,mid-1);
		else tp=insert(rc[x],d,mid+1,r);
		pushup(x);
		
		if(isbad(x)) sgt=&x,ssl=l,ssr=r;
		return tp;
	}

	int ins(node d){
		sgt=0;
		int x=insert(root,d,0,INF);//前面写-INF算mid会炸掉 
		if(sgt) rebuild(sgt,ssl,ssr);
		return x;
	}
}SGT;

struct segtree{
	int mx[M];
	int gmx(int x,int y){
		if(rk[pos[x]]==rk[pos[y]]) return x<y?x:y;
		return rk[pos[x]]>rk[pos[y]]?x:y;
	}
	void pushup(int x){
		mx[x]=gmx(mx[x<<1],mx[x<<1|1]);
	}
	void build(int x,int l,int r){
		if(l==r){
			mx[x]=l;
			return;
		}
		int mid=l+r>>1;
		build(x<<1,l,mid);
		build(x<<1|1,mid+1,r);
		pushup(x);
	}
	void mdf(int x,int l,int r,int to){
		if(l==r) return;
		int mid=l+r>>1;
		if(to<=mid) mdf(x<<1,l,mid,to);
		else mdf(x<<1|1,mid+1,r,to);
		pushup(x);
	}
	int get(int x,int l,int r,int tl,int tr){
		if(tl<=l&&r<=tr) return mx[x];
		int mid=l+r>>1;
		if(tl<=mid&&mid<tr)
			return gmx(get(x<<1,l,mid,tl,tr),get(x<<1|1,mid+1,r,tl,tr));
		if(tl<=mid) return get(x<<1,l,mid,tl,tr);
		if(mid<tr) return get(x<<1|1,mid+1,r,tl,tr);
	}
}Seg;

int main(){
	int i,x,y,z;
	n=rd(), m=rd();
	SGT.ins(node(0,0));
	for(i=1;i<=n;i++) pos[i]=1;
	Seg.build(1,1,n);
	for(i=1;i<=m;i++){
		scanf("%s",s);
		if(s[0]=='C'){
			x=rd(),y=rd(),z=rd();
			node nw=node(pos[x],pos[y]);
			pos[z]=SGT.ins(nw);
			Seg.mdf(1,1,n,z);
		}
		else{
			x=rd(),y=rd();
			printf("%d\n",Seg.get(1,1,n,x,y));
		}
	}
	return 0;
}