bzoj1941 [Sdoi2010]Hide and Seek kd树

Description

---

给定n个二维平面上的点，求从一个点出发到达其他点的最大距离与最小距离之差最小，输出最小值
这题的距离指的是曼哈顿距离

对于30%的数据,N<=1000 对于100%的数据，N<=500000,0<=X,Y<=10^8 保证数据没有重点保证N>=2

Solution

---

一开始看错题了以为是直线距离，飞速码完调了几下发现过不了是因为建树的时候并没有分割。。
考虑枚举每个点作为起点，那么比较当前点的最近点距离和最远点距离之差即可。直接上kd树

需要注意的是在求最大值的时候要稍稍改动估价函数使得复杂度比较优秀，这个脑补一下就ojbk

Code

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define rep(i,st,ed) for (int i=st;i<=ed;++i)

const int INF=0x3f3f3f3f;
const int N=5000005;

struct treeNode {int d[2],max[2],min[2],l,r;} t[N];

int tot,D,ret;

int read() {
    int x=0,v=1; char ch=getchar();
    for (;ch<'0'||ch>'9';v=(ch=='-')?(-1):(v),ch=getchar());
    for (;ch<='9'&&ch>='0';x=x*10+ch-'0',ch=getchar());
    return x*v;
}

void push_up(int x) {
    if (t[x].l) {
        t[x].min[0]=std:: min(t[x].min[0],t[t[x].l].min[0]);
        t[x].min[1]=std:: min(t[x].min[1],t[t[x].l].min[1]);
        t[x].max[0]=std:: max(t[x].max[0],t[t[x].l].max[0]);
        t[x].max[1]=std:: max(t[x].max[1],t[t[x].l].max[1]);
    }
    if (t[x].r) {
        t[x].min[0]=std:: min(t[x].min[0],t[t[x].r].min[0]);
        t[x].min[1]=std:: min(t[x].min[1],t[t[x].r].min[1]);
        t[x].max[0]=std:: max(t[x].max[0],t[t[x].r].max[0]);
        t[x].max[1]=std:: max(t[x].max[1],t[t[x].r].max[1]);
    }
}

bool cmp(treeNode a,treeNode b) {
    return a.d[D]<b.d[D]||a.d[D]==b.d[D]&&a.d[!D]<b.d[!D];
}

int get_min_dis(int x,int l,int r) {
    int ret=0;
    ret+=std:: max(0,l-t[x].max[0]);
    ret+=std:: max(0,t[x].min[0]-l);
    ret+=std:: max(0,r-t[x].max[1]);
    ret+=std:: max(0,t[x].min[1]-r);
    return ret;
}

int get_max_dis(int x,int l,int r) {
    int ret=0;
    ret+=std:: max(abs(t[x].max[0]-l),abs(l-t[x].min[0]));
    ret+=std:: max(abs(t[x].max[1]-r),abs(r-t[x].min[1]));
    return ret;
}

void query_min(int now,int l,int r,int d) {
    int dis=abs(t[now].d[0]-l)+abs(t[now].d[1]-r);
    if (dis!=0) ret=std:: min(dis,ret);
    int dl=INF,dr=INF;
    if (t[now].l) dl=get_min_dis(t[now].l,l,r);
    if (t[now].r) dr=get_min_dis(t[now].r,l,r);
    if (dl<dr) {
        if (dl<ret) query_min(t[now].l,l,r,!d);
        if (dr<ret) query_min(t[now].r,l,r,!d);
    } else {
        if (dr<ret) query_min(t[now].r,l,r,!d);
        if (dl<ret) query_min(t[now].l,l,r,!d);
    }
}

void query_max(int now,int l,int r,int d) {
    int dis=abs(t[now].d[0]-l)+abs(t[now].d[1]-r);
    ret=std:: max(dis,ret);
    int dl=0,dr=0;
    if (t[now].l) dl=get_max_dis(t[now].l,l,r);
    if (t[now].r) dr=get_max_dis(t[now].r,l,r);
    if (dl>dr) {
        if (dl>ret) query_max(t[now].l,l,r,!d);
        if (dr>ret) query_max(t[now].r,l,r,!d);
    } else {
        if (dr>ret) query_max(t[now].r,l,r,!d);
        if (dl>ret) query_max(t[now].l,l,r,!d);
    }
}

int build_tree(int l,int r,int d) {
    int mid=(l+r)>>1; D=d;
    std:: nth_element(t+l,t+mid,t+r+1,cmp);
    t[mid].l=t[mid].r=0;
    t[mid].max[0]=t[mid].min[0]=t[mid].d[0];
    t[mid].max[1]=t[mid].min[1]=t[mid].d[1];
    if (l<mid) t[mid].l=build_tree(l,mid-1,!d);
    if (mid<r) t[mid].r=build_tree(mid+1,r,!d);
    push_up(mid);
    return mid;
}

int main(void) {
    int n=read();
    rep(i,1,n) t[i].d[0]=read(),t[i].d[1]=read();
    int root=build_tree(1,n,0);
    int ans=INF;
    rep(i,1,n) {
        ret=INF; query_min(root,t[i].d[0],t[i].d[1],0);
        int tmp=ret; ret=0; query_max(root,t[i].d[0],t[i].d[1],0);
        ans=std:: min(ret-tmp,ans);
    }
    printf("%d\n", ans);
    return 0;
}