模板—K-D-tree(P2479 [SDOI2010]捉迷藏)

 #include<algorithm>
 #include<iostream>
 #include<cstdio>
 #include<cmath>
 #define LL long long
 #define MAXN 1000100
 using namespace std;
 inline LL min(LL a,LL b){return a<b?a:b;}
 int n,cmpid;
 struct point
 {
     int x[];
     friend bool operator < (point a,point b)
     {return a.x[cmpid]<b.x[cmpid];}
 }p[MAXN];
 struct tree
 {
     point p;
     int mn[],mx[],l,r;
     #define l(x) tr[x].l
     #define r(x) tr[x].r
     #define p(x) tr[x].p
 }tr[MAXN];
 int Dis(point a,point b)
 {
     return abs(a.x[]-b.x[])+abs(a.x[]-b.x[]);
 }
 int min_dis(tree a,point b)
 {
     int x=max(a.mn[]-b.x[],)+max(b.x[]-a.mx[],);
     int y=max(a.mn[]-b.x[],)+max(b.x[]-a.mx[],);
     return x+y;
 }
 int max_dis(tree a,point b)
 {
     int x=max(abs(a.mx[]-b.x[]),abs(b.x[]-a.mn[]));
     int y=max(abs(a.mx[]-b.x[]),abs(b.x[]-a.mn[]));
     return x+y;
 }
 struct KDtree
 {
     int root,tot,ans;
     #define INF 0x7fffffff
     void ask_max(point a,int x,int k)
     {
         if(!x)return;int tem;
         if((tem=Dis(p(x),a))>ans)ans=tem;
         int l=l(x),r=r(x);
         if(a.x[k]<p(x).x[k])swap(l,r);
         if(max_dis(tr[l],a)>ans)ask_max(a,l,k^);
         if(max_dis(tr[r],a)>ans)ask_max(a,r,k^);
     }
     int ask_max(point a)
     {
         ans=-INF;
         ask_max(a,root,);
         return ans;
     }
     void ask_min(point a,int x,int k)
     {
         if(!x)return;int tem;
         if((tem=Dis(p(x),a))<ans&&tem!=)ans=tem;
         int l=l(x),r=r(x);
         if(a.x[k]>p(x).x[k])swap(l,r);//如果a在x有右半区间，先向右搜索。
         if(min_dis(tr[l],a)<ans)ask_min(a,l,k^);
         if(min_dis(tr[r],a)<ans)ask_min(a,r,k^);
     }
     int ask_min(point a)
     {
         ans=INF;
         ask_min(a,root,);
         return ans;
     }
     void updata(int x)
     {
         if(!x)return;
         if(l(x))
             tr[x].mn[]=min(tr[x].mn[],tr[l(x)].mn[]),
             tr[x].mn[]=min(tr[x].mn[],tr[l(x)].mn[]),
             tr[x].mx[]=max(tr[x].mx[],tr[l(x)].mx[]),
             tr[x].mx[]=max(tr[x].mx[],tr[l(x)].mx[]);
         if(r(x))
             tr[x].mn[]=min(tr[x].mn[],tr[r(x)].mn[]),
             tr[x].mn[]=min(tr[x].mn[],tr[r(x)].mn[]),
             tr[x].mx[]=max(tr[x].mx[],tr[r(x)].mx[]),
             tr[x].mx[]=max(tr[x].mx[],tr[r(x)].mx[]);
     }
     void build(int &x,int l,int r,int k)
     {
         if(l>r)return;
         x=++tot;int mid=(l+r)>>;
         cmpid=k;
         nth_element(p+l,p+mid,p+r+);
         p(x)=p[mid];
         tr[x].mn[]=tr[x].mx[]=p(x).x[];
         tr[x].mn[]=tr[x].mx[]=p(x).x[];
         build(l(x),l,mid-,k^);
         build(r(x),mid+,r,k^);
         updata(x);
     }
     void build()
     {
         tot=;
         build(root,,n,);
     }
 }T;
 signed main()
 {
     cin>>n;
     for(int i=;i<=n;i++)
         cin>>p[i].x[]>>p[i].x[];
     T.build();
     LL ans=INF;
     for(int i=;i<=n;i++)
     {
         ans=min(ans,T.ask_max(p[i])-T.ask_min(p[i]));
     }
     cout<<ans<<endl;
 }
     

放一下‘天使玩偶’的标程：

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LL long long
using namespace std;
int n,m,cmpid;
struct point
{
    int x[];
    friend bool operator < (point a,point b)
    {return a.x[cmpid]<b.x[cmpid];}
}p[];
struct tree
{
    point p;
    int mx[],mn[],l,r;
    #define l(x) tr[x].l
    #define r(x) tr[x].r
    #define p(x) tr[x].p
}tr[];
int dis(point a,point b){return abs(a.x[]-b.x[])+abs(a.x[]-b.x[]);}
int min_dis(tree a,point b)
{
    int x=max(a.mn[]-b.x[],)+max(b.x[]-a.mx[],);
    int y=max(a.mn[]-b.x[],)+max(b.x[]-a.mx[],);
    return x+y;
}
struct KD_tree
{
    int root,tot,ans;
    #define INF 0x7fffffff
    void ask_min(point a,int x,int k)
    {
        if(!x)return;int tem;
        if((tem=dis(p(x),a))<ans)ans=tem;
        int l=l(x),r=r(x);
        if(a.x[k]>p(x).x[k])swap(l,r);
        if(min_dis(tr[l],a)<ans)ask_min(a,l,k^);
        if(min_dis(tr[r],a)<ans)ask_min(a,r,k^);
    }
    int ask_min(point a)
    {
        ans=INF;ask_min(a,root,);
        return ans;
    }
    void updata(int x)
    {
        if(!x)return;
        if(l(x))
            tr[x].mn[]=min(tr[x].mn[],tr[l(x)].mn[]),
            tr[x].mn[]=min(tr[x].mn[],tr[l(x)].mn[]),
            tr[x].mx[]=max(tr[x].mx[],tr[l(x)].mx[]),
            tr[x].mx[]=max(tr[x].mx[],tr[l(x)].mx[]);
        if(r(x))
            tr[x].mn[]=min(tr[x].mn[],tr[r(x)].mn[]),
            tr[x].mn[]=min(tr[x].mn[],tr[r(x)].mn[]),
            tr[x].mx[]=max(tr[x].mx[],tr[r(x)].mx[]),
            tr[x].mx[]=max(tr[x].mx[],tr[r(x)].mx[]);
    }
    void build(int &x,int l,int r,int k)
    {
        if(l>r)return;
        x=++tot;int mid=(l+r)>>;
        cmpid=k;
        nth_element(p+l,p+mid,p+r+);
        p(x)=p[mid];
        tr[x].mn[]=tr[x].mx[]=p(x).x[];
        tr[x].mn[]=tr[x].mx[]=p(x).x[];
        build(l(x),l,mid-,k^);
        build(r(x),mid+,r,k^);
        updata(x);
    }
    void build(){tot=;build(root,,n,);}
    void insert(point a,int &x,int k)
    {
        if(!x)
        {
            x=++tot;p(x)=a;
            tr[x].mn[]=tr[x].mx[]=p(x).x[];
            tr[x].mn[]=tr[x].mx[]=p(x).x[];
            return;
        }
        if(a.x[k]<p(x).x[k])insert(a,l(x),k^);
        else insert(a,r(x),k^);
        updata(x);
    }
    void insert(point a){insert(a,root,);}
}T;
signed main()
{
    cin>>n>>m;
    for(int i=;i<=n;i++)cin>>p[i].x[]>>p[i].x[];
    T.build();int t,x,y;
    for(int i=;i<=m;i++)
    {
        cin>>t>>x>>y;
        if(t==)T.insert((point){x,y});
        else cout<<T.ask_min((point){x,y})<<endl;;
    }
}