【BZOJ】2675: Bomb

题意：

给n个点，任选其中3个点（一个点只能取一次），求选出三个点的最大曼哈顿距离之和与最小曼哈顿距离之和（n<=10^5）。

题解：

最大曼哈顿距离之和很好求，就是能包围所有点的经过三个点的矩阵周长。

考虑最小曼哈顿距离之和。

我们考虑一个点，那么另外两个点会有两种分布。由于对称性，我们只考虑当前枚举的点在右上角、剩下两个点在左下角的情况。如果能求出这种情况的最优值，那么我们可以通过坐标系的旋转，使得剩下的情况也计算到了（这是做出本题的关键）。

可以发现曼哈顿距离就是包含三个点的最小矩形周长。

为了方便，我们假设每个点对应的坐标互不相同。（而实际中要考虑三个点或两个点有坐标相同的情况）

一、当剩下两个点其中一个点不在这个矩形上：

此时问题可以转化为，我们枚举中间这个点，然后统计

1、这个点与它的左下角和右上角

2、这个点与它的左上角和右下角

这两种情况的答案。

我们可以按y轴排序然后维护x轴的前缀最值求出一个方向的最值，然后通过坐标系的旋转求出每个方向的最值（注意实际中要讨论点重合的情况）

二、两个点都在矩阵上：

我们同样先y轴排序然后从小到大枚举。

假设右上角的点为1号点，剩下两个点为2、3号点（不必考虑这两个点谁上谁下，因为标号是自己定的..）

那么可以得到答案是：

\[2(x_1+y_1-(x_2+y_3))
\]

那么我们用线段树维护一下\((x_2+y_3)\)的最值，即单点更新\(y_i\)和区间更新\(x_i\)以及区间查询\(x_i+y_i\)

那么问题解决。

写的时候注意一下情况一中两个点重合的情况（不特判一下会使得左上右下都是重合的另一个点的答案..）

时间复杂度：\(O(nlogn)\)

#include <bits/stdc++.h>
using namespace std;
const int N=100005, MN=-(~0u>>1), MX=~0u>>1;
inline int icmp(int a, int b, int w) { return w?min(a, b):max(a, b); }
int n, ans1=MN, ans2=MX, nbit, nseg, bit[N][2];
struct ip {
	int x, y, id;
	void scan(int _id) {
		scanf("%d%d", &x, &y);
		id=_id;
	}
}p[N], a[N];
bool cmpy(const ip &a, const ip &b) { return a.y==b.y?(a.x==b.x?a.id<b.id:a.x<b.x):a.y<b.y; }
void bitrebuild(int s) {
	nbit=s;
	for(int i=1; i<=nbit; ++i) bit[i][0]=MN, bit[i][1]=MX;
}
void bitupdate(int x, int s) {
	for(; x<=nbit; x+=x&-x) bit[x][0]=max(bit[x][0], s), bit[x][1]=min(bit[x][1], s);
}
int bitask(int x, int w) {
	int r=icmp(MN, MX, w^1); for(; x; x-=x&-x) r=icmp(r, bit[x][w], w);
	return r;
}
struct node *null;
struct node {
	node *c[2];
	int x[2], y[2], go[2];
	void up() {
		x[0]=max(c[0]->x[0], c[1]->x[0]);
		x[1]=min(c[0]->x[1], c[1]->x[1]);
		y[0]=max(c[0]->y[0], c[1]->y[0]);
		y[1]=min(c[0]->y[1], c[1]->y[1]);
	}
	void upd(int g, int w) {
		if(this==null) return;
		if(abs(y[w])<MX) x[w]=icmp(x[w], g+y[w], w);
		go[w]=icmp(go[w], g, w);
	}
	void down() {
		if(go[0]!=MN) c[0]->upd(go[0], 0), c[1]->upd(go[0], 0), go[0]=MN;
		if(go[1]!=MX) c[0]->upd(go[1], 1), c[1]->upd(go[1], 1), go[1]=MX;
	}
	void init() {
		x[0]=y[0]=go[0]=MN;
		x[1]=y[1]=go[1]=MX;
		c[0]=c[1]=null;
	}
}Po[N<<2], *iT=Po, *root;
node *newnode() { iT->init(); return iT++; }
void seginit() { null=iT++; null->init(); }
void segrebuild(int l, int r, node *&x) {
	x=newnode();
	if(l==r) return;
	int mid=(l+r)>>1;
	segrebuild(l, mid, x->c[0]); segrebuild(mid+1, r, x->c[1]);
}
void segrebuild(int s) { iT=&Po[1]; nseg=s; segrebuild(1, s, root); }
int segask(int L, int R, int w, int l, int r, node *x) {
	if(L<=l && r<=R) return x->x[w];
	x->down();
	int mid=(l+r)>>1, ret=icmp(MN, MX, w^1);
	if(L<=mid) ret=segask(L, R, w, l, mid, x->c[0]);
	if(mid<R) ret=icmp(ret, segask(L, R, w, mid+1, r, x->c[1]), w);
	return ret;
}
void segupdate1(int p, int s, int l, int r, node *x) {
	if(l==r) {
		x->y[0]=max(x->y[0], s);
		x->y[1]=min(x->y[1], s);
		return;
	}
	x->down();
	int mid=(l+r)>>1;
	if(p<=mid) segupdate1(p, s, l, mid, x->c[0]);
	else segupdate1(p, s, mid+1, r, x->c[1]);
	x->up();
}
void segupdate2(int L, int R, int s, int l, int r, node *x) {
	if(L<=l && r<=R) {
		x->upd(s, 0);
		x->upd(s, 1);
		return;
	}
	x->down();
	int mid=(l+r)>>1;
	if(L<=mid) segupdate2(L, R, s, l, mid, x->c[0]);
	if(mid<R) segupdate2(L, R, s, mid+1, r, x->c[1]);
	x->up();
}
int segask(int x, int w) { return segask(1, x, w, 1, nseg, root); }
void segupdate1(int s, int x) { segupdate1(x, s, 1, nseg, root); }
void segupdate2(int s, int x) { segupdate2(x, nseg, s, 1, nseg, root); }
void readin() {
	scanf("%d", &n);
	for(int i=1; i<=n; ++i)
		p[i].scan(i);
}
int pos[N], cnt;
void lisan() {
	static int ax[N];
	for(int i=1; i<=n; ++i) ax[i]=a[i].x;
	sort(ax+1, ax+1+n);
	cnt=unique(ax+1, ax+1+n)-ax-1;
	sort(a+1, a+1+n, cmpy);
	for(int i=1; i<=n; ++i) pos[i]=lower_bound(ax+1, ax+1+cnt, a[i].x)-ax;
}
void getans1(int d[N][2]) {
	bitrebuild(cnt);
	for(int i=1; i<=n; ++i) {
		int ps=pos[i];
		d[a[i].id][0]=bitask(ps, 0),
		d[a[i].id][1]=bitask(ps, 1);
		bitupdate(ps, a[i].x+a[i].y);
	}
}
void getans2() {
	segrebuild(cnt);
	for(int i=1; i<=n; ++i) {
		int ps=pos[i], x=a[i].x, y=a[i].y, temp;
		temp=segask(ps, 1); if(temp!=MX) ans1=max(ans1, (x+y-temp)<<1);
		temp=segask(ps, 0); if(temp!=MN) ans2=min(ans2, (x+y-temp)<<1);
		segupdate2(x, ps);
		segupdate1(y, ps);
	}
}
void trans() {
	for(int i=1; i<=n; ++i) {
		int x=p[i].x, y=p[i].y;
		p[i].x=-y; p[i].y=x;
	}
}
int ar[4][N][2];
void work() {
	for(int k=0; k<4; ++k) {
		for(int i=1; i<=n; ++i) a[i]=p[i];
		lisan();
		if(k>=2) for(int i=2; i<=n; ++i) if(a[i].x==a[i-1].x && a[i].y==a[i-1].y) swap(a[i].id, a[i-1].id);
		getans1(ar[k]);
		getans2();
		trans();
	}
	for(int i=1; i<=n; ++i) {
		if(abs(ar[2][i][1])<MX && abs(ar[0][i][1])<MX) ans1=max(ans1, (-ar[2][i][1]-ar[0][i][1])<<1);
		if(abs(ar[3][i][1])<MX && abs(ar[1][i][1])<MX) ans1=max(ans1, (-ar[3][i][1]-ar[1][i][1])<<1);
		if(abs(ar[2][i][0])<MX && abs(ar[0][i][0])<MX) ans2=min(ans2, (-ar[2][i][0]-ar[0][i][0])<<1);
		if(abs(ar[3][i][0])<MX && abs(ar[1][i][0])<MX) ans2=min(ans2, (-ar[3][i][0]-ar[1][i][0])<<1);
	}
}
int main() {
	seginit();
	readin();
	work();
	printf("%d\n%d\n", ans1, ans2);
	return 0;
}