数据 (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;
}