洛谷P4848 崂山白花蛇草水 权值线段树+KDtree

题目描述

神犇 \(Aleph\) 在 \(SDOI\ Round2\) 前立了一个 \(flag\)：如果进了省队，就现场直播喝崂山白花蛇草水。凭借着神犇 \(Aleph\) 的实力，他轻松地进了山东省省队，现在便是他履行诺言的时候了。蒟蒻 \(Bob\) 特地为他准备了 \(999,999,999,999,999,999\) 瓶崂山白花蛇草水，想要灌神犇 \(Aleph\)。神犇 \(Aleph\) 求（跪着的）蒟蒻 \(Bob\) 不要灌他，由于神犇 \(Aleph\) 是神犇，蒟蒻 \(Bob\) 最终答应了他的请求，但蒟蒻 \(Bob\) 决定将计就计，也让神犇 $Aleph4 回答一些问题。

具体说来，蒟蒻 \(Bob\) 会在一个宽敞的广场上放置一些崂山白花蛇草水（可视为二维平面上的一些整点），然后询问神犇 \(Aleph\) 在矩形区域 \(x_1\le x\le x_2,y_1\le y\le y_2\) 中，崂山白花蛇草水瓶数第 \(k\) 多的是多少。为了避免麻烦，蒟蒻 \(Bob\) 不会在同一个位置放置两次或两次以上的崂山白花蛇草水，但蒟蒻 \(Bob\) 想为难一下神犇 \(Aleph\)，希望他能在每次询问时立刻回 答出答案。

神犇 \(Aleph\) 不屑于做这种问题，所以把这个问题交给了你。

输入格式

输入的第一行为两个正整数 \(n\)，\(q\)，表示横纵坐标的范围和蒟蒻 \(Bob\) 的操作次数（包括放置次数和询问次数）。

接下来 \(q\) 行，每行代表蒟蒻 \(Bob\) 的一个操作，操作格式如下：

首先第一个数字 \(\mathrm{type}\)，表示操作种类。\(\mathrm{type}=1\) 表示放置，\(\mathrm{type}=2\) 表示询问。

若 \(\mathrm{type}=1\)，接下来会有三个正整数 \(x, y, v\)，表示在坐标整点 \((x, y)\) 放置v瓶崂山白花蛇草水。

若 \(\mathrm{type}=2\)，接下来会有五个正整数 \(x_1, y_1, x_2, y_2, k\)，表示询问矩形区域 \(x_1\le x\le x_2,y_1\le y\le y_2\)​ 中，崂山白花蛇草水瓶数第 \(k\) 多的是多少。

为了体现程序的在线性，你需要将每次读入的数据（除了 \(\mathrm{type}\) 值）都异或 \(\mathrm{lastans}\)，其中 \(\mathrm{lastans}\) 表示上次询问的答 案。如果上次询问的答案为 \(NAIVE!ORZzyz\).（见样例输出），则将 \(\mathrm{lastans}\) 置为 \(0\)。初始时的 \(\mathrm{lastans}\) 为 \(0\)。 初始时平面上不存在崂山白花蛇草水。

输出格式

对于每个 \(\mathrm{type}=2\) 的操作，一行输出崂山白花蛇草水瓶数第 \(k\) 多的是多少。若不存在第 \(k\) 多的瓶数， 请输出 \(NAIVE!ORZzyz.\)。

输入输出样例

输入 #1

10 7
1 1 1 1
1 2 2 3
1 4 1 2
1 3 4 4
2 1 1 4 1 3
2 2 2 3 5 4
2 2 1 4 4 2

输出 #1

NAIVE!ORZzyz.
NAIVE!ORZzyz.
3

说明/提示

对于所有数据，\(n\le500000\)，\(q\le100000\)，\(1\le x, y\le n\)，\(1\le v\le 10^9\)，\(1\le x_1\le x_2\le n\)，\(1\le y_1\le y_2\le n\)，\(1\le k\le q\)。

分析

在给定的矩形内查询第 \(k\) 大的权值

动态加点，强制在线

这种题一个非常好想的做法就是开一个小根堆维护最大的 \(k\) 个元素

每次只更新队首的元素

这种做法在 \(k\) 比较小的情况下是没有问题的

然而这道题 \(k\) 的范围达到了 \(10^5\) ，显然会 \(T\) 到飞起

所以我们需要另一种能够支持查询区间 \(k\) 大值的数据结构，比如权值线段树

权值线段树的每个节点上都维护一棵 \(kdtree\)

\(kdtree\) 中存储权值为当前节点下标的所有点的坐标

因为要动态加点，为了防止二叉树退化成一条链，需要借鉴替罪羊的思想暴力重构

要注意的是，暴力重构时，不能这样写

void dfs(rg int da){
	sta[++tp]=da;
	jl[tp]=ktr[da];
	if(ktr[da].lc) dfs(ktr[da].lc);
	if(ktr[da].rc) dfs(ktr[da].rc);
}

而要这样写

void dfs(rg int da){
	sta[++tp]=da;
	jl[tp].d[0]=ktr[da].d[0];
	jl[tp].d[1]=ktr[da].d[1];
	if(ktr[da].lc) dfs(ktr[da].lc);
	if(ktr[da].rc) dfs(ktr[da].rc);
}

因为你直接继承 \(min\) 和 \(max\) 会对之后节点的更新造成影响

代码

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<cmath>
#define rg register
inline int read(){
	rg int x=0,fh=1;
	rg char ch=getchar();
	while(ch<'0' || ch>'9'){
		if(ch=='-') fh=-1;
		ch=getchar();
	}
	while(ch>='0' && ch<='9'){
		x=(x<<1)+(x<<3)+(ch^48);
		ch=getchar();
	}
	return x*fh;
}
const int maxn=1e6+5,INF=1e9;
const double alpha=0.75;
inline int Max(rg int aa,rg int bb){
	return aa>bb?aa:bb;
}
inline int Min(rg int aa,rg int bb){
	return aa<bb?aa:bb;
}
int orz,kcnt,sta[maxn],tp;
struct kdt{
	int lc,rc,mn[2],mx[2],d[2],siz;
	friend bool operator <(const kdt& A,const kdt& B){
		return A.d[orz]<B.d[orz];
	}
}ktr[maxn*5],jl[maxn*5];
inline int newnode(){
	if(tp) return sta[tp--];
	else return ++kcnt;
}
void push_up(rg int da){
	rg int lc=ktr[da].lc,rc=ktr[da].rc;
	for(rg int i=0;i<2;i++){
		ktr[da].mn[i]=ktr[da].mx[i]=ktr[da].d[i];
		if(lc){
			ktr[da].mn[i]=Min(ktr[da].mn[i],ktr[lc].mn[i]);
			ktr[da].mx[i]=Max(ktr[da].mx[i],ktr[lc].mx[i]);
		}
		if(rc){
			ktr[da].mn[i]=Min(ktr[da].mn[i],ktr[rc].mn[i]);
			ktr[da].mx[i]=Max(ktr[da].mx[i],ktr[rc].mx[i]);
		}
	}
	ktr[da].siz=ktr[lc].siz+ktr[rc].siz+1;
}
int build(rg int l,rg int r,rg int pl){
	orz=pl;
	rg int da=newnode(),mids=(l+r)>>1;
	std::nth_element(jl+l,jl+mids,jl+r+1);
	ktr[da]=jl[mids];
	if(l<mids) ktr[da].lc=build(l,mids-1,!pl);
	if(mids<r) ktr[da].rc=build(mids+1,r,!pl);
	push_up(da);
	return da;
}
void dfs(rg int da){
	sta[++tp]=da;
	jl[tp].d[0]=ktr[da].d[0];
	jl[tp].d[1]=ktr[da].d[1];
	if(ktr[da].lc) dfs(ktr[da].lc);
	if(ktr[da].rc) dfs(ktr[da].rc);
}
void check(rg int &da,rg int pl){
	rg int lc=ktr[da].lc,rc=ktr[da].rc;
	if(ktr[lc].siz>ktr[da].siz*alpha || ktr[rc].siz>ktr[da].siz*alpha){
		tp=0;
		dfs(da);
		da=build(1,tp,pl);
	}
}
int ad(rg int da,rg int nx,rg int ny,rg int pl){
	if(!da){
		da=newnode();
		ktr[da].mn[0]=ktr[da].mx[0]=ktr[da].d[0]=nx;
		ktr[da].mn[1]=ktr[da].mx[1]=ktr[da].d[1]=ny;
		ktr[da].siz=1;
		return da;
	}
	if(pl==0){
		if(nx<ktr[da].d[0]) ktr[da].lc=ad(ktr[da].lc,nx,ny,!pl);
		else ktr[da].rc=ad(ktr[da].rc,nx,ny,!pl);
	} else {
		if(ny<ktr[da].d[1]) ktr[da].lc=ad(ktr[da].lc,nx,ny,!pl);
		else ktr[da].rc=ad(ktr[da].rc,nx,ny,!pl);
	}
	push_up(da);
	if(ktr[da].siz>6) check(da,pl);
	return da;
}
int cx(rg int da,rg int a1,rg int a2,rg int b1,rg int b2){
	if(!da) return 0;
	if(ktr[da].mx[0]<a1 || ktr[da].mn[0]>a2 || ktr[da].mx[1]<b1 || ktr[da].mn[1]>b2) return 0;
	if(ktr[da].mx[0]<=a2 && ktr[da].mn[0]>=a1 && ktr[da].mx[1]<=b2 && ktr[da].mn[1]>=b1){
		return ktr[da].siz;
	}
	rg int nans=0;
	if(ktr[da].d[0]<=a2 && ktr[da].d[0]>=a1 && ktr[da].d[1]<=b2 && ktr[da].d[1]>=b1)  nans++;
	nans+=cx(ktr[da].lc,a1,a2,b1,b2);
	nans+=cx(ktr[da].rc,a1,a2,b1,b2);
	return nans;
}
struct trr{
	int lc,rc;
}tr[maxn*10];
int rk[maxn],cnt,rt;
int xg(rg int da,rg int l,rg int r,rg int wz,rg int nx,rg int ny){
	if(!da) da=++cnt;
	rg int mids=(l+r)>>1;
	rk[da]=ad(rk[da],nx,ny,0);
	if(l==r) return da;
	if(wz<=mids) tr[da].lc=xg(tr[da].lc,l,mids,wz,nx,ny);
	else tr[da].rc=xg(tr[da].rc,mids+1,r,wz,nx,ny);
	return da;
}
int trcx(rg int da,rg int l,rg int r,rg int kth,rg int a1,rg int a2,rg int b1,rg int b2){
	if(l==r) return l;
	rg int nans=cx(rk[tr[da].rc],a1,a2,b1,b2),mids=(l+r)>>1;
	if(nans>=kth) return trcx(tr[da].rc,mids+1,r,kth,a1,a2,b1,b2);
	else return trcx(tr[da].lc,l,mids,kth-nans,a1,a2,b1,b2);
}
int n,q,latans;
int main(){
	n=read(),q=read();
	rg int aa,bb,cc,dd,ee,ff;
	for(rg int i=1;i<=q;i++){
		aa=read(),bb=read(),cc=read(),dd=read();
		bb^=latans,cc^=latans,dd^=latans;
		if(aa==1){
			rt=xg(rt,1,INF,dd,bb,cc);
		} else {
			ee=read(),ff=read();
			ee^=latans,ff^=latans;
			if(cx(rk[rt],bb,dd,cc,ee)<ff){
				printf("NAIVE!ORZzyz.\n");
				latans=0;
			} else {
				printf("%d\n",latans=trcx(rt,1,INF,ff,bb,dd,cc,ee));
			}
		}
	}
	return 0;
}