【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;
}

转载于:https://www.cnblogs.com/iwtwiioi/p/4985750.html