數據 (cdq分治)

題意：維護二維平面上的點集，支持插入一個點，查詢點集中的點到指定點的最小、最大曼哈頓距離。不強制在線，n,m<=10w。

考試的時候沒怎麼動腦子，直接上分象限討論+線段樹套平衡樹，花了2h寫了7k結果常數太大隻得了50分。

爲了降低常數，採用cdq分治。有一個特殊的技巧，就是不需要按象限分類，只討論x,y都比當前小的情況，其他情況可以將座標軸對稱四次得到。按x座標排序，然後按時間來劃分，用樹狀數組來維護y的前綴最值。然後爲了卡常注意在分治內部遇到沒有詢問，或者不可能產生貢獻的區間就提前跳出。

以後不強制在線的三維偏序乾脆直接上cdq啊！又快內存又小還好寫。

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#define rep(i,a,b) for(int i=a;i<=b;++i)
#define erp(i,a,b) for(int i=a;i>=b;--i)
using namespace std;
const int MAXN = 100005;
const int inf = 0x3f3f3f3f;
inline void gmin(int&a, const int&b) { if(a>b) a=b; }
inline void gmax(int&a, const int&b) { if(a<b) a=b; }

template<typename T>
void get(T&x) {
	char c; x = 0;
	do c=getchar(); while (c<'0'||c>'9');
	do x=x*10+c-'0',c=getchar(); while (c>='0'&&c<='9');
}

int N, Q, pn;
int op[MAXN], ox[MAXN], oy[MAXN], ans[MAXN];
int daty[MAXN*2], yn;
int idxy(int y) { return lower_bound(daty+1, daty+yn+1, y) - daty; }

struct dot {
	int x, y, t, loc, xi, yi;
	dot () {}
	dot (int a, int b, int c, int d) : x(a), y(b), t(c), loc(d) {}
} a[MAXN * 2], po[MAXN * 2];
bool cmpx(const dot&a, const dot&b)
{ return a.x!=b.x ? a.x<b.x : a.y<b.y; }

int bd = 100000005;
int c1[MAXN*2], c2[MAXN*2]; //c1保存前綴最小值，c2存前綴最大值，按離散後的y座標排序。

void set1(int *c, int i, int v)
{
	for (; i<=yn; i+=i&-i)
		if (v < c[i]) c[i] = v;
}
void set2(int *c, int i, int v)
{
	for (; i<=yn; i+=i&-i)
		if (v > c[i]) c[i] = v;
}
int qmax(int *c, int i)
{
	int r = -inf;
	for (; i>0; i-=i&-i)
		if (r<c[i]) r = c[i];
	return r;
}
int qmin(int *c, int i)
{
	int r = inf;
	for (; i>0; i-=i&-i)
		if (r>c[i]) r = c[i];
	return r;
}

void cdq(int L, int R)
{
	if (L == R) return;
	int mid = (L+R)>>1, l1 = L, l2 = mid+1;
	int ql = 0, qr = 0;
	rep(i, L, R)
	{
		if (a[i].t <= mid) { po[l1++] = a[i]; if (a[i].loc) ++ql; }
		else { po[l2++] = a[i]; if (a[i].loc) ++qr; }
	}
	if (!qr || !(mid-L+1-ql)) return;
	rep(i, L, R) a[i] = po[i];
	int i = L, j = mid+1;
	for (; j<=R; ++j)
	{
		for (; a[i].x <= a[j].x && i <= mid; ++i)
		{
			if (a[i].loc) continue;
			set1(c1, a[i].yi, a[i].x + a[i].y);
			set2(c2, a[i].yi, a[i].x + a[i].y);
		}
		if (op[a[j].loc] == 1) gmin(ans[a[j].loc], a[j].x + a[j].y - qmax(c2, a[j].yi));
		if (op[a[j].loc] == 2) gmax(ans[a[j].loc], a[j].x + a[j].y - qmin(c1, a[j].yi));
	}
	for (; i>=L; --i) if (!a[i].loc) set2(c1, a[i].yi, inf), set1(c2, a[i].yi, -inf);
	if (ql) cdq(L, mid);
	if (qr) cdq(mid+1, R);
}

void solve()
{
	yn = 0;
	rep(i, 1, pn) daty[++yn] = a[i].y;
	sort(daty+1, daty+yn+1);
	yn = unique(daty+1, daty+yn+1) - daty-1;
	rep(i, 1, yn) c1[i] = inf, c2[i] = -inf;
	sort(a+1, a+pn+1, cmpx);
	rep(i, 1, pn) a[i].yi = idxy(a[i].y);
	cdq(1, pn);
}

int main()
{
	freopen("data.in", "r", stdin);
	freopen("data.out", "w", stdout);
	get(N);
	rep(i, 1, N) get(a[i].x), get(a[i].y), a[i].t = i;
	get(Q); pn = N;
	rep(i, 1, Q)
	{
		get(op[i]), get(ox[i]), get(oy[i]);
		++pn, a[pn] = dot(ox[i], oy[i], pn, op[i] ? i : 0);
		if (op[i]==1) ans[i] = inf;
		else if (op[i]==2) ans[i] = -inf;
	}
	solve();
	rep(i, 1, pn) a[i].x = bd - a[i].x;
	solve();
	rep(i, 1, pn) a[i].y = bd - a[i].y;
	solve();
	rep(i, 1, pn) a[i].x = bd - a[i].x;
	solve();
	rep(i, 1, Q) if (op[i]) printf("%d\n", ans[i]);
	return 0;
}

考試時候寫的250行7k結果常數爆炸的樹套樹，留個紀念吧23333

#include<algorithm>
#include<cstdio>
#include<cstring>
#define rep(i,a,b) for(int i=a;i<=b;++i)
#define erp(i,a,b) for(int i=a;i>=b;--i)
#define idx(L,R) ((L+R)|(L!=R))
using namespace std;
const int MAXN = 100005, MAXS = MAXN*50;
const int inf = 0x3f3f3f3f;

template<typename T>
void get(T&x) {
	char c; x = 0;
	do c=getchar(); while (c<'0'||c>'9');
	do x=x*10+c-'0',c=getchar(); while (c>='0'&&c<='9');
}

int N, Q;
int dat[MAXN*2], dn;
int xp[MAXN], yp[MAXN];
int op[MAXN], ox[MAXN], oy[MAXN];
inline int bh(int v) { return lower_bound(dat+1, dat+dn+1, v)-dat; }

int ran()
{
	static int sd = 1237;
	return sd = (sd*1237)&0x7fffffff;
}

#define lch(x) ch[x][0]
#define rch(x) ch[x][1]
int root[MAXN*4];
namespace Treap
{
	int ch[MAXS][2], vx[MAXS], vy[MAXS], fix[MAXS], ncnt;
	int mx1[MAXS], mx2[MAXS], mi1[MAXS], mi2[MAXS];
	void init()
	{
		mx1[0] = -inf, mx2[0] = -inf;
		mi1[0] = inf, mi2[0] = inf;
	}
	inline void pushup(int&x)
	{
		mx1[x] = mi1[x] = vx[x] + vy[x];
		mx2[x] = mi2[x] = vx[x] - vy[x];
		mx1[x] = max(mx1[x], max(mx1[lch(x)], mx1[rch(x)]));
		mi1[x] = min(mi1[x], min(mi1[lch(x)], mi1[rch(x)]));
		mx2[x] = max(mx2[x], max(mx2[lch(x)], mx2[rch(x)]));
		mi2[x] = min(mi2[x], min(mi2[lch(x)], mi2[rch(x)]));
	}
	inline void rotate(int&x, const int&d)
	{
		int y = ch[x][!d];
		ch[x][!d] = ch[y][d];
		ch[y][d] = x;
		pushup(x), pushup(x = y);
	}
	inline int NewNode(const int&tx, const int&ty)
	{
		vx[++ncnt] = tx, vy[ncnt] = ty;
		fix[ncnt] = ran();
		mx1[ncnt] = mi1[ncnt] = vx[ncnt] + vy[ncnt];
		mx2[ncnt] = mi2[ncnt] = vx[ncnt] - vy[ncnt];
		return ncnt;
	}
	inline void ins0(int&x, const int&tx, const int&ty)
	{
		if (!x) { x = NewNode(tx,ty), fix[x] = (MAXS-ncnt)<<4; return; }
		int d = (ty>vy[x]);
		ins0(ch[x][d], tx, ty), pushup(x);
	}
	inline void ins(int&x, const int&tx, const int&ty)
	{
		if (!x) { x = NewNode(tx,ty); return; }
		int d = (ty>vy[x]);
		ins(ch[x][d], tx, ty);
		if (fix[ch[x][d]] > fix[x]) rotate(x, !d);
		pushup(x);
	}
	inline int ask1(int &x, const int&ty) //查找y>=ty的最大x+y
	{
		if (!x) return -inf;
		if (vy[x] < ty) return ask1(rch(x), ty);
		return max(max(mx1[rch(x)], vx[x]+vy[x]), ask1(lch(x), ty));
	}
	inline int ask2(int &x, const int&ty) //查找y>=ty的最小x+y
	{
		if (!x) return inf;
		if (vy[x] < ty) return ask2(rch(x), ty);
		return min(min(mi1[rch(x)], vx[x]+vy[x]), ask2(lch(x), ty));
	}
	inline int ask3(int &x, const int&ty) //查找y<ty的最大x-y
	{
		if (!x) return -inf;
		if (vy[x] >= ty) return ask3(lch(x), ty);
		return max(max(mx2[lch(x)], vx[x]-vy[x]), ask3(rch(x), ty));
	}
	inline int ask4(int &x, const int&ty) //查找y<ty的最小x-y
	{
		if (!x) return inf;
		if (vy[x] >= ty) return ask4(lch(x), ty);
		return min(min(mi2[lch(x)], vx[x]-vy[x]), ask4(rch(x), ty));
	}
	inline int ask5(int &x, const int&ty) //查找y>=ty的最大x-y
	{
		if (!x) return -inf;
		if (vy[x] < ty) return ask5(rch(x), ty);
		return max(max(mx2[rch(x)], vx[x]-vy[x]), ask5(lch(x), ty));
	}
	inline int ask6(int &x, const int&ty) //查找y>=ty的最小x-y
	{
		if (!x) return inf;
		if (vy[x] < ty) return ask6(rch(x), ty);
		return min(min(mi2[rch(x)], vx[x]-vy[x]), ask6(lch(x), ty));
	}
	inline int ask7(int &x, const int&ty) //查找y<ty的最大x+y
	{
		if (!x) return -inf;
		if (vy[x] >= ty) return ask7(lch(x), ty);
		return max(max(mx1[lch(x)], vx[x]+vy[x]), ask7(rch(x), ty));
	}
	inline int ask8(int &x, const int&ty) //查找y<ty的最小x+y
	{
		if (!x) return inf;
		if (vy[x] >= ty) return ask8(lch(x), ty);
		return min(min(mi1[lch(x)], vx[x]+vy[x]), ask8(rch(x), ty));
	}
}

void ins0(int xi, int x, int y, int L, int R)
{
	Treap::ins0(root[idx(L, R)], x, y);
	if (L == R) return;
	int mid = (L+R)>>1;
	if (xi<=mid) ins0(xi, x, y, L, mid);
	else ins0(xi, x, y, mid+1, R);
}

void ins(int xi, int x, int y, int L, int R)
{
	Treap::ins(root[idx(L, R)], x, y);
	if (L == R) return;
	int mid = (L+R)>>1;
	if (xi<=mid) ins(xi, x, y, L, mid);
	else ins(xi, x, y, mid+1, R);
}

inline int ask1(int xi, int yi, int L, int R) //求x>=xi, y>=yi的最大x+y
{
	if (R<xi) return -inf;
	if (L>=xi) return Treap::ask1(root[idx(L, R)], yi);
	int mid = (L+R)>>1;
	return max(ask1(xi, yi, L, mid), ask1(xi, yi, mid+1, R));
}

inline int ask2(int xi, int yi, int L, int R) //求x>=xi, y>=yi的最小x+y
{
	if (R<xi) return inf;
	if (L>=xi) return Treap::ask2(root[idx(L, R)], yi);
	int mid = (L+R)>>1;
	return min(ask2(xi, yi, L, mid), ask2(xi, yi, mid+1, R));
}

inline int ask3(int xi, int yi, int L, int R) //求x>=xi, y<yi的最大x-y
{
	if (R<xi) return -inf;
	if (L>=xi) return Treap::ask3(root[idx(L, R)], yi);
	int mid = (L+R)>>1;
	return max(ask3(xi, yi, L, mid), ask3(xi, yi, mid+1, R));
}

inline int ask4(int xi, int yi, int L, int R) //求x>=xi, y<yi的最小x-y
{
	if (R<xi) return inf;
	if (L>=xi) return Treap::ask4(root[idx(L, R)], yi);
	int mid = (L+R)>>1;
	return min(ask4(xi, yi, L, mid), ask4(xi, yi, mid+1, R));
}

inline int ask5(int xi, int yi, int L, int R) //求x<xi, y>=yi的最大x-y
{
	if (L>=xi) return -inf;
	if (R<xi) return Treap::ask5(root[idx(L, R)], yi);
	int mid = (L+R)>>1;
	return max(ask5(xi, yi, L, mid), ask5(xi, yi, mid+1, R));
}

inline int ask6(int xi, int yi, int L, int R) //求x<xi, y>=yi的最小x-y
{
	if (L>=xi) return inf;
	if (R<xi) return Treap::ask6(root[idx(L, R)], yi);
	int mid = (L+R)>>1;
	return min(ask6(xi, yi, L, mid), ask6(xi, yi, mid+1, R));
}

inline int ask7(int xi, int yi, int L, int R) //求x<xi, y<yi的最大x+y
{
	if (L>=xi) return -inf;
	if (R<xi) return Treap::ask7(root[idx(L, R)], yi);
	int mid = (L+R)>>1;
	return max(ask7(xi, yi, L, mid), ask7(xi, yi, mid+1, R));
}

inline int ask8(int xi, int yi, int L, int R) //求x<xi, y<yi的最小x+y
{
	if (L>=xi) return inf;
	if (R<xi) return Treap::ask8(root[idx(L, R)], yi);
	int mid = (L+R)>>1;
	return min(ask8(xi, yi, L, mid), ask8(xi, yi, mid+1, R));
}

inline int solve1(int x, int y) //離它最近的
{
	int xi = bh(x);
	int r1 = ask2(xi, y, 1, dn) - (x+y);
	int r2 = ask4(xi, y, 1, dn) - (x-y);
	int r3 = (x-y) - ask5(xi, y, 1, dn);
	int r4 = (x+y) - ask7(xi, y, 1, dn);
	r2 = min(r2, r1), r3 = min(r3, r2), r4 = min(r4, r3);
	return r4;
}

inline int solve2(int x, int y) //離它最遠的
{
	int xi = bh(x);
	int r1 = ask1(xi, y, 1, dn) - (x+y);
	int r2 = ask3(xi, y, 1, dn) - (x-y);
	int r3 = (x-y) - ask6(xi, y, 1, dn);
	int r4 = (x+y) - ask8(xi, y, 1, dn);
	r2 = max(r2, r1), r3 = max(r3, r2), r4 = max(r4, r3);
	return r4;
}

int main()
{
	Treap::init();
	get(N);
	int u, v;
	rep(i, 1, N) get(xp[i]), get(yp[i]), dat[++dn] = xp[i];
	rep(i, 1, N) u=ran()%N+1, v=ran()%N+1, swap(xp[u], xp[v]), swap(yp[u], yp[v]);
	get(Q);
	rep(i, 1, Q) get(op[i]), get(ox[i]), get(oy[i]), dat[++dn] = ox[i];
	sort(dat+1, dat+dn+1);
	dn = unique(dat+1, dat+dn+1) -dat-1;
	rep(i, 1, N) ins0(bh(xp[i]), xp[i], yp[i], 1, dn);
	rep(i, 1, Q)
	{
		if (op[i] == 0) ins(bh(ox[i]), ox[i], oy[i], 1, dn);
		else if (op[i] == 1) printf("%d\n", solve1(ox[i], oy[i]));
		else printf("%d\n", solve2(ox[i], oy[i]));
	}
	return 0;
}