bzoj1941 Hide and Seek(kd_Tree模板题)

题目链接：bzoj1941 Hide and Seek

题意：求每个点到其中任意一个点的最大值和最小值的差的最小值。

注意：最小值初始化不能设为0，因为不能是同一个点。

/**************************************************************
    Problem: 1941
    User: Revincent
    Language: C++
    Result: Accepted
    Time:1644 ms
    Memory:16452 kb
****************************************************************/
 
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define N 500005
#define inf 0x3f3f3f3f
using namespace std;
 
int n,root,d;
int Min,Max,X,Y;
 
struct node
{
    int l,r,xy[2],Max[2],Min[2];
    friend bool operator < (node a, node b)
    {
        if(a.xy[d] == b.xy[d])
             return a.xy[d^1] < b.xy[d^1];
        return a.xy[d] < b.xy[d];
    }
}p[N];
 
int scan()
{
    int v = 0,f = 1;
    char c;
    while((c=getchar())==' ' || c == '\n');
    if(c == '-')f = -1;
    else v = c - '0';
    while((c = getchar()) != ' ' && c != '\n')
        v = v * 10 + c - '0';
    return v * f;
}
 
void push_up(int rt, int ch)
{
    p[rt].Min[0] = min(p[rt].Min[0], p[ch].Min[0]);
    p[rt].Min[1] = min(p[rt].Min[1], p[ch].Min[1]);
    p[rt].Max[0] = max(p[rt].Max[0], p[ch].Max[0]);
    p[rt].Max[1] = max(p[rt].Max[1], p[ch].Max[1]);
}
 
int build(int l, int r, int o)
{
    int mid = (l + r) >> 1;
    d = o;
    nth_element(p+l, p+mid, p+r+1);
    p[mid].Min[0] = p[mid].Max[0] = p[mid].xy[0];
    p[mid].Min[1] = p[mid].Max[1] = p[mid].xy[1];
    p[mid].l = p[mid].r = 0;
    if(l < mid)p[mid].l = build(l, mid-1, o^1);
    if(r > mid)p[mid].r = build(mid+1, r, o^1);
    if(p[mid].l)push_up(mid, p[mid].l);
    if(p[mid].r)push_up(mid, p[mid].r);
    return mid;
}
 
int get_min(node a)
{
    int res = 0;
    if(X > a.Max[0])res += X - a.Max[0];
    if(X < a.Min[0])res += a.Min[0] - X;
    if(Y > a.Max[1])res += Y - a.Max[1];
    if(Y < a.Min[1])res += a.Min[1] - Y;
    return res;
}
 
void query_min(int rt)
{
    int dis = abs(p[rt].xy[0] - X) + abs(p[rt].xy[1] - Y);
    if(dis)Min = min(Min, dis);
    int lmin = inf,rmin = inf;
    if(p[rt].l)lmin = get_min(p[p[rt].l]);
    if(p[rt].r)rmin = get_min(p[p[rt].r]);
    if(lmin < rmin)
    {
        if(lmin < Min)query_min(p[rt].l);
        if(rmin < Min)query_min(p[rt].r);
    }
    else
    {
        if(rmin < Min)query_min(p[rt].r);
        if(lmin < Min)query_min(p[rt].l);
    }
}
 
int get_max(node a)
{
    int res = 0;
    res += max(abs(a.Min[0]-X), abs(a.Max[0]-X));
    res += max(abs(a.Min[1]-Y), abs(a.Max[1]-Y));
    return res;
}
 
void query_max(int rt)
{
    int dis = abs(p[rt].xy[0] - X) + abs(p[rt].xy[1] - Y);
    if(dis)Max = max(Max, dis);
    int lmax = -inf,rmax = -inf;
    if(p[rt].l)lmax = get_max(p[p[rt].l]);
    if(p[rt].r)rmax = get_max(p[p[rt].r]);
    if(lmax > rmax)
    {
        if(lmax > Max)query_max(p[rt].l);
        if(rmax > Max)query_max(p[rt].r);
    }
    else
    {
        if(rmax > Max)query_max(p[rt].r);
        if(lmax > Max)query_max(p[rt].l);
    }
}
 
int main()
{
    while(~scanf("%d", &n))
    {
        for(int i = 1; i <= n; ++i)
            p[i].xy[0] = scan(),p[i].xy[1] = scan();
        root = build(1, n, 0);
        int ans = inf;
        for(int i = 1; i <= n; ++i)
        {
            X = p[i].xy[0],Y = p[i].xy[1];
            Min = inf,Max = -inf;
            query_min(root),query_max(root);
            ans = min(ans, Max - Min);
        }
        printf("%d\n", ans);
    }
    return 0;
}