[bzoj2648/2716]SJY摆棋子

平面上有n个点，要求支持插入一个点和查询一个点的最近点距离 n,m<=500000

用kdtree实现，但是复杂度貌似没法保证.....（莫名加了替罪羊重建更慢了...)

#include<iostream>
#include<cstdio>
#include<algorithm>
#define INF 2000000000
#define MN 1000000
using namespace std;
inline int read()
{
    int x =  , f = ; char ch = getchar();
    while(ch < '' || ch > ''){ if(ch == '-') f = -;  ch = getchar();}
    while(ch >= '' && ch <= ''){x = x *  + ch - '';ch = getchar();}
    return x * f;
}
int n,now,m;
inline int abs(int x){return x<?-x:x;}
struct P{
    int d[],mx[],mn[],l,r;
    int& operator[](int x){return d[x];}
    bool operator<(const P&x)const{return d[now]<x.d[now];}
    friend int dis(P x,P y){return abs(x.d[]-y.d[])+abs(x.d[]-y.d[]);}
}t[MN+];

struct KD_TREE{
    P p[MN+],T;int ans;
    void update(int x)
    {
        int l=p[x].l,r=p[x].r;
        for(int i=;i<;i++)
        {
            if(l) p[x].mn[i]=min(p[x].mn[i],p[l].mn[i]),
                  p[x].mx[i]=max(p[x].mx[i],p[l].mx[i]);
            if(r) p[x].mn[i]=min(p[x].mn[i],p[r].mn[i]),
                  p[x].mx[i]=max(p[x].mx[i],p[r].mx[i]);
        }
    }
    void ins(int x,int th)
    {
        if(T[th]>=p[x][th])
        {
            if(p[x].r) ins(p[x].r,th^);
            else
            {
                int r=p[x].r=++n;p[r]=T;
                for(int i=;i<;i++)
                    p[r].mn[i]=p[r].mx[i]=T[i];
            }
        }
        else
        {
            if(p[x].l) ins(p[x].l,th^);
            else
            {
                int l=p[x].l=++n;p[l]=T;
                for(int i=;i<;i++)
                    p[l].mn[i]=p[l].mx[i]=T[i];
            }
        }
        update(x);
    }
    int getmn(P x)
    {
        int sum=;
        for(int i=;i<;i++)
        {
            sum+=max(x.mn[i]-T[i],);
            sum+=max(T[i]-x.mx[i],);
        }
        return sum;
    }
    int build(int l,int r,int th)
    {
        int mid=l+r>>;now=th;
        nth_element(t+l,t+mid,t+r+);
        p[mid]=t[mid];
        for(int i=;i<;i++)
            p[mid].mx[i]=p[mid].mn[i]=p[mid][i];
        if(l<mid) p[mid].l=build(l,mid-,th^);
        if(mid<r) p[mid].r=build(mid+,r,th^);
        update(mid);
        return mid;
    }
    void querymn(int k)
    {
        ans=min(ans,dis(p[k],T));
        int dl=INF,dr=INF;
        if(p[k].l) dl=getmn(p[p[k].l]);
        if(p[k].r) dr=getmn(p[p[k].r]);
        if(dl>dr)
        {
            if(dr<ans) querymn(p[k].r);
            if(dl<ans) querymn(p[k].l);
        }
        else
        {
            if(dl<ans) querymn(p[k].l);
            if(dr<ans) querymn(p[k].r);
        }
    }
}kd;
int rt,ans=INF;

int main()
{
    n=read();m=read();
    for(int i=;i<=n;i++)
        t[i][]=read(),t[i][]=read();
    rt=kd.build(,n,);
    for(int i=;i<=m;i++)
    {
        int op=read();kd.T[]=read();kd.T[]=read();
        if(op==) kd.ins(rt,);
        else
        {
            kd.ans=INF;kd.querymn(rt);
            printf("%d\n",kd.ans);
        }
    }
    return ;
}