「LOJ #6016」崂山白花蛇草水

Description

在一个 (n imes n) 的二维平面上，支持两种操作，操作共 (q) 组：

• 加入一个 权值为 (v) 的二维点 ((x,y))。
• 在所有满足 (x_1 le xle x_2 ext{ and } y_1le yle y_2) 的点中，找出点权第 (k) 大的点，输出它的点权。或者判断是否存在。

强制在线。

Hint

(1le nle 5 imes 10^5,1le qle 10^5)

(1le vle 10^9,1le kle q)

Solution

题目有一个操作是求 ( ext{k-th})，那么很容易想到权值线段树，而且实现十分简单。

下面是（动态开点）权值线段树 的 查找 ( ext{k-th}) 的代码：

int sgtQueryKth(int k,int l=1,int r=INT_MAX,int rt=sgtRt) {
	if(!rt) return -1;
	if(l==r) return l;
	int mid=(l+r)>>1;
	if(size[rc[rt]]>=k)
		return sgtQueryKth(k,mid+1,r,rc[rt]);
	else
		return sgtQueryKth(k-size[rc[rt]],l,mid,lc[rt]);
}

其中，size[rc[rt]] 是 全局 中 结点 rc[rt] 所管辖值域中的 元素的个数。

然而现在我们有了限制，怎么办？我们需要快速计算 限定矩形范围 中 结点 rc[rt] 所管辖值域中的 元素的个数。

那么不难想到用 KD-Tree 来维护，实际上就是二维数点。再具体一点，就是 权值线段树的每个结点 都维护一个 KD-Tree，对于权值线段树上的结点 rt 那么 rt 上的 KDT 就维护着 结点 rt 所管辖的值域中的所有二维点。

所有，只需要再原来朴素的权值线段树的代码上，改一下……

int sgtQueryKth(int xL,int xR,int yL,int yR,int k,int l=1,int r=V,int rt=sgtRt) {
	if(l==r) return l;
	int insideCnt=kdtCount(xL,xR,yL,yR,kdtRt[rc[rt]]); // 在当前结点的右儿子的 KDT 上做二维数点。
	if(insideCnt>=k)//之后的所有原来的 size[rc[rt]] 都换为 insideCnt
		return sgtQueryKth(xL,xR,yL,yR,k,mid+1,r,rc[rt]);
	else
		return sgtQueryKth(xL,xR,yL,yR,k-insideCnt,l,mid,lc[rt]);
}

emm……基本没变？？

是的。

那么插入的操作也可以很快写出来了：

void sgtUpdate(int *dat,int v,int l=1,int r=V,int &rt=sgtRt) {//dat[0] => x坐标，dat[1] => y坐标
	if(!rt) rt=++sgtNCnt;
	kdtInsert(dat,kdtRt[rt]);//原本为 size[rt]+=v ，现换成 KDT 的插入
	if(l==r) return;
	if(v<=mid) sgtUpdate(dat,v,l,mid,lc[rt]);
	else sgtUpdate(dat,v,mid+1,r,rc[rt]);
        //不要直接 pushup，随便想想就知道那样子复杂度会爆炸，应使用 Path-update 的方式。
}

那么，这就是传说中的树套树中的 权值线段树 套 KD-Tree 了！

【镇楼】

权值线段树 套 KDT 的图示：

Code

完整代码（O2）

/*
 * Author : _Wallace_
 * Source : https://www.cnblogs.com/-Wallace-/
 * Problem : LOJ #6016 崂山白花蛇草水
 */
#include<cstdio>
#include<algorithm>
#include<utility>
using namespace std;

namespace fastIO_int {
	int get_int() {
		int x=0,f=1;char c=getchar();
		while(c<'0'||c>'9')	{
			if(c=='-')f=-1;
			c=getchar();
		}
		while(c>='0'&&c<='9')
			x=x*10+c-'0',c=getchar();
		return f*x;
	}
	
	void read(){}
	template<class T1,class ...T2>
	void read(T1 &i,T2&... rest) {
		i=get_int();
		read(rest...);
	}
	
	void put_int(int x) {
		if(x<0)putchar('-'),x=-x;
		if(x>9)put_int(x/10);
		putchar(x%10+'0');
	}
	
	void write(){}
	template<class T1,class ...T2>
	void write(T1 i,T2... rest) {
		put_int(i),putchar(' ');
		write(rest...);
	}
};

const int V=1e9;
const int N=1e5+5;
#define lc(x) tree[x].lc
#define rc(x) tree[x].rc
struct Node {
	int lc,rc,size;
	int dat[2];
	int Max[2],Min[2];
	Node() {
		lc=rc=size=0;
		dat[0]=dat[1]=0;
		Max[0]=Max[1]=Min[0]=Min[1]=0;
	}
	Node(int x,int y) {
		lc=rc=0,size=1;
		dat[0]=x,dat[1]=y;
		Max[0]=Min[0]=x,Max[1]=Min[1]=y;
	}
	inline int& operator [] (const int &t) {
		return dat[t];
	}
}tree[N<<6];
int kdtNCnt;
inline void maintain(int rt) {
	for(register int i=0;i<2;i++) {
		tree[rt].Max[i]=tree[rt].Min[i]=tree[rt][i];
		if(lc(rt)) {
			tree[rt].Max[i]=max(tree[rt].Max[i],tree[lc(rt)].Max[i]);
			tree[rt].Min[i]=min(tree[rt].Min[i],tree[lc(rt)].Min[i]);
		}
		if(rc(rt)) {
			tree[rt].Max[i]=max(tree[rt].Max[i],tree[rc(rt)].Max[i]);
			tree[rt].Min[i]=min(tree[rt].Min[i],tree[rc(rt)].Min[i]);
		}
	}
	tree[rt].size=tree[lc(rt)].size+tree[rc(rt)].size+1;
}
namespace kdtRebuildPart {
	#define alpha 0.75
	pair<int,int> pnt[N];
	int stk[N],top=0;
	struct comparator {
		int dim;
		inline bool operator () (const pair<int,int> &x,const pair<int,int> &y) const {
			if(dim==0) return x.first < y.first;
			else return x.second < y.second;
		}
	}cmp;
	int build(int l,int r,int d) {
		if(l>r) return 0;
		int rt=stk[top--], mid=(l+r)>>1;
		cmp.dim=d;
		nth_element(pnt+l,pnt+mid,pnt+r+1,cmp);
		tree[rt]=Node(pnt[mid].first,pnt[mid].second);
		lc(rt)=build(l,mid-1,d^1);
		rc(rt)=build(mid+1,r,d^1);
		return maintain(rt),rt;
	}
	void destroy(int rt) {
		if(!rt) return;
		stk[++top]=rt;
		pnt[top]=make_pair(tree[rt][0],tree[rt][1]);
		destroy(lc(rt));
		destroy(rc(rt));
	}
	inline bool isBalanced(int rt) {
		if(tree[rt].size*alpha<tree[lc(rt)].size*1.0) return false;
		if(tree[rt].size*alpha<tree[rc(rt)].size*1.0) return false;
		return true;
	}
	inline void rebuild(int &rt,int d) {
		if(isBalanced(rt)) return;
		top=0,destroy(rt);
		rt=build(1,top,d);
	}
	#undef alpha
}
void kdtInsert(int *dat,int &rt,int d=0) {
	if(!rt) {
		rt=++kdtNCnt;
		tree[rt]=Node(dat[0],dat[1]);
		return;
	}
	if(dat[d]<=tree[rt][d])
		kdtInsert(dat,lc(rt),d^1);
	else
		kdtInsert(dat,rc(rt),d^1);
	maintain(rt);
	kdtRebuildPart::rebuild(rt,d);
}
inline bool allIn(int xL,int xR,int yL,int yR,int rt) {
	return (tree[rt].Max[0]<=xR&&tree[rt].Max[1]<=yR&&tree[rt].Min[0]>=xL&&tree[rt].Min[1]>=yL);
}
inline bool allOut(int xL,int xR,int yL,int yR,int rt) {
	return (tree[rt].Max[0]<xL||tree[rt].Max[1]<yL||tree[rt].Min[0]>xR||tree[rt].Min[1]>yR);
}
inline int checkIn(int xL,int xR,int yL,int yR,int rt) {
	return !(tree[rt][0]<xL||tree[rt][0]>xR||tree[rt][1]<yL||tree[rt][1]>yR);
}
int kdtCount(int xL,int xR,int yL,int yR,int rt) {
	if(!rt) return 0;
	if(allIn(xL,xR,yL,yR,rt)) return tree[rt].size;
	if(allOut(xL,xR,yL,yR,rt)) return 0;
	int ret=checkIn(xL,xR,yL,yR,rt);
	return ret+kdtCount(xL,xR,yL,yR,lc(rt))+kdtCount(xL,xR,yL,yR,rc(rt));
}
#undef lc
#undef rc

#define mid ((l+r)>>1)
int kdtRt[N<<4];
int lc[N<<4],rc[N<<4];
int sgtNCnt=0;
int sgtRt=0;

void sgtUpdate(int *dat,int v,int l=1,int r=V,int &rt=sgtRt) {
	if(!rt) rt=++sgtNCnt;
	kdtInsert(dat,kdtRt[rt]);
	if(l==r) return;
	if(v<=mid) sgtUpdate(dat,v,l,mid,lc[rt]);
	else sgtUpdate(dat,v,mid+1,r,rc[rt]);
}
int sgtQueryKth(int xL,int xR,int yL,int yR,int k,int l=1,int r=V,int &rt=sgtRt) {
	if(l==r) return l;
	int insideCnt=kdtCount(xL,xR,yL,yR,kdtRt[rc[rt]]);
	if(insideCnt>=k)
		return sgtQueryKth(xL,xR,yL,yR,k,mid+1,r,rc[rt]);
	else
		return sgtQueryKth(xL,xR,yL,yR,k-insideCnt,l,mid,lc[rt]);
}
#undef mid

int n,q;
signed main() {
	using fastIO_int::read;
	using fastIO_int::write;
	read(n,q);
	for(int last=0;q;--q) {
		int cmd; read(cmd);
		if(cmd==1) {
			int dat[2],v;
			read(dat[0],dat[1],v);
			dat[0]^=last;
			dat[1]^=last;
			v^=last;
			sgtUpdate(dat,v);
		} else {
			int xL,yL,xR,yR,k;
			read(xL,yL,xR,yR,k);
			xL^=last,xR^=last;
			yL^=last,yR^=last;
			k^=last;
			if(kdtCount(xL,xR,yL,yR,kdtRt[sgtRt])<k) {
				last=0;
				puts("NAIVE!ORZzyz.");
			} else {
				last=sgtQueryKth(xL,xR,yL,yR,k);
				write(last),putchar('
');
			}
		}
	}
	return 0;
}