BZOJ4533 [BeiJing2014 WinterCamp] 数据

本文版权归ljh2000和博客园共有，欢迎转载，但须保留此声明，并给出原文链接，谢谢合作。

本文作者：ljh2000
作者博客：http://www.cnblogs.com/ljh2000-jump/
转载请注明出处，侵权必究，保留最终解释权！

Description

为了写论文，Alex经常要整理大量的数据。 这一次，Alex面临一个严峻的考验：他需要实现一个数据结构来维护一个点集。 

现在，二维平面上有N个点。Alex 需要实现以下三种操作： 

1. 在点集里添加一个点； 

2. 给出一个点，查询它到点集里所有点的曼哈顿距离的最小值； 

3. 给出一个点，查询它到点集里所有点的曼哈顿距离的最大值。 

两个点的曼哈顿距离定义为它们的横坐标差的绝对值与纵坐标差的绝对值的和。这么困难的问题，Alex当然不会做，只好再次请你帮忙了。 

Input

第一行包含一个整数N，表示点集最初的点数。 

接下来N行，每行两个整数，依次表示每个点的横坐标和纵坐标。 

第N+2行包含一个整数Q，表示询问的数目。 

接下来Q行，每行三个整数，依次表示询问的类型，点的横坐标和纵坐标。0类型表示添加一个点，1类型表示查询到该点的曼哈顿距离的最小值，2类型表示查询最大值。 

1 ≤ N, Q ≤ 100,000，点的坐标是不超过10^9的非负整数

Output

输出若干行，依次表示每个查询操作的答案。 

Sample Input

3
7 5
6 2
3 1
5
1 6 1
1 5 5
2 7 1
0 3 2
1 1 0

Sample Output

1
2
4
3

 

 

正解：kd-tree

解题报告：

　　kd-tree模板题。学习kd-tree出门右转：http://www.cnblogs.com/ljh2000-jump/tag/kd-tree/

　　然而这道题我的常数无比巨大，实在找不到问题......　　

 

//It is made by ljh2000
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
typedef long long LL;
const int MAXN = 200011;
const int inf = 2000000001;
int n,m,nowD,root,ql,qr,ans;
struct KDTree{ int d[2],Min[2],Max[2],l,r; }t[MAXN];
inline bool cmp(KDTree q,KDTree qq){ if(q.d[nowD]==qq.d[nowD]) return q.d[nowD^1]<qq.d[nowD^1]; return q.d[nowD]<qq.d[nowD]; }
inline void init(int x){ for(int i=0;i<2;i++) t[x].Min[i]=t[x].Max[i]=t[x].d[i]; }
inline int count_min(int x){
	int dd=0;
    if(t[x].Min[0]>ql) dd+=t[x].Min[0]-ql;
    if(t[x].Max[0]<ql) dd+=ql-t[x].Max[0];
    if(t[x].Min[1]>qr) dd+=t[x].Min[1]-qr;
    if(t[x].Max[1]<qr) dd+=qr-t[x].Max[1];
    return dd;
}
inline int count_max(int x){ return max(abs(t[x].Min[0]-ql),abs(t[x].Max[0]-ql))+max(abs(t[x].Min[1]-qr),abs(t[x].Max[1]-qr)); }
inline int getint(){
    int w=0,q=0; char c=getchar(); while((c<'0'||c>'9') && c!='-') c=getchar();
    if(c=='-') q=1,c=getchar(); while (c>='0'&&c<='9') w=w*10+c-'0',c=getchar(); return q?-w:w;
}
 
inline void update(int x){
	int l=t[x].l,r=t[x].r;
	if(l) {
		if(t[l].Min[0]<t[x].Min[0]) t[x].Min[0]=t[l].Min[0];
		if(t[l].Max[0]>t[x].Max[0]) t[x].Max[0]=t[l].Max[0];
		if(t[l].Min[1]<t[x].Min[1]) t[x].Min[1]=t[l].Min[1];
		if(t[l].Max[1]>t[x].Max[1]) t[x].Max[1]=t[l].Max[1];
	}
	if(r) {
		if(t[r].Min[0]<t[x].Min[0]) t[x].Min[0]=t[r].Min[0];
		if(t[r].Max[0]>t[x].Max[0]) t[x].Max[0]=t[r].Max[0];
		if(t[r].Min[1]<t[x].Min[1]) t[x].Min[1]=t[r].Min[1];
		if(t[r].Max[1]>t[x].Max[1]) t[x].Max[1]=t[r].Max[1];
	}
}
 
inline int build(int l,int r,int D){
	nowD=D; int mid=(l+r)>>1; nth_element(t+l+1,t+mid+1,t+r+1,cmp);
	if(l<mid) t[mid].l=build(l,mid-1,D^1);
	if(mid<r) t[mid].r=build(mid+1,r,D^1);
	init(mid); update(mid);
	return mid;
}
 
inline void insert(){
	int u=root; int D=0;
	while(1) {
		if(t[u].Min[0]>t[n].d[0]) t[u].Min[0]=t[n].d[0];
		if(t[u].Max[0]<t[n].d[0]) t[u].Max[0]=t[n].d[0];
		if(t[u].Min[1]>t[n].d[1]) t[u].Min[1]=t[n].d[1];
		if(t[u].Max[1]<t[n].d[1]) t[u].Max[1]=t[n].d[1];
 
		if(t[n].d[D]<=t[u].d[D]) {
			if(!t[u].l) { t[u].l=n; return ; }
			else u=t[u].l;
		}
		else{
			if(!t[u].r) { t[u].r=n; return ; }
			else u=t[u].r;
		}
		D^=1;
	}
}
 
inline void query_max(int u){
	int dl=0,dr=0,dd=abs(t[u].d[0]-ql)+abs(t[u].d[1]-qr); if(dd>ans) ans=dd;
	if(t[u].l) dl=count_max(t[u].l); if(t[u].r) dr=count_max(t[u].r);
	if(dl>dr) {
		if(dl>ans) query_max(t[u].l);
		if(dr>ans) query_max(t[u].r);
	}
	else{
		if(dr>ans) query_max(t[u].r);
		if(dl>ans) query_max(t[u].l);
	}
}
 
inline void query_min(int u){
	int dl=inf,dr=inf,dd=abs(t[u].d[0]-ql)+abs(t[u].d[1]-qr); if(dd<ans) ans=dd;
	if(t[u].l) dl=count_min(u); if(t[u].r) dr=count_min(u);
	if(dl<dr) {
		if(dl<ans) query_min(t[u].l);
		if(dr<ans) query_min(t[u].r);
	}
	else{
		if(dr<ans) query_min(t[u].r);
		if(dl<ans) query_min(t[u].l);
	}
}
 
inline void work(){
	n=getint(); for(int i=1;i<=n;i++) t[i].d[0]=getint(),t[i].d[1]=getint();
	root=build(1,n,0); m=getint(); int ljh,x,y;
	while(m--) {
		ljh=getint(); x=getint(); y=getint();
		if(ljh==0) { t[++n].d[0]=x; t[n].d[1]=y; init(n); insert(); }
		else if(ljh==1) {
			ql=x; qr=y; ans=abs(t[1].d[0]-ql)+abs(t[1].d[1]-qr);
			query_min(root);
			printf("%d\n",ans);
		}
		else{
			ql=x; qr=y; ans=abs(t[1].d[0]-ql)+abs(t[1].d[1]-qr);
			query_max(root);
			printf("%d\n",ans);
		}
	}
}
 
int main()
{
    work();
    return 0;
}