BZOJ2648/2716:SJY摆棋子/[Violet]天使玩偶(K-D Tree)

Description

这天，SJY显得无聊。在家自己玩。在一个棋盘上，有N个黑色棋子。他每次要么放到棋盘上一个黑色棋子，要么放上一个白色棋子，如果是白色棋子，他会找出距离这个白色棋子最近的黑色棋子。此处的距离是 曼哈顿距离 即(|x1-x2|+|y1-y2|) 。现在给出N<=500000个初始棋子。和M<=500000个操作。对于每个白色棋子，输出距离这个白色棋子最近的黑色棋子的距离。同一个格子可能有多个棋子。

Input

第一行两个数 N M

以后M行，每行3个数 t x y

如果t=1 那么放下一个黑色棋子

如果t=2 那么放下一个白色棋子

Output

对于每个T=2 输出一个最小距离

Sample Input

2 3
1 1
2 3
2 1 2
1 3 3
2 4 2

Sample Output

1
2

Solution

K-D Tree模板题，注意不替罪羊重构的话会TLE

Code

 #include<iostream>
 #include<cstring>
 #include<cstdlib>
 #include<cstdio>
 #include<algorithm>
 #define N (1000000+1000)
 #define INF 0x7fffffff
 using namespace std;

 int n,m,D,ans,opt,x,y,Root;
 double alpha=0.75;

 struct Node
 {
     int d[],Max[],Min[],lson,rson,size;
     bool operator < (const Node &a) const {return d[D]<a.d[D];}
     Node (int x=,int y=)
     {
         lson=rson=; d[]=x; d[]=y;;
         Max[]=Min[]=d[];
         Max[]=Min[]=d[];
     }
 }p[N],T;

 int stack[N],cnt,top;
 int NewNode()
 {
     if (top) return stack[top--];
     return ++cnt;
 }

 struct KDT
 {
     Node Tree[N];

     void Update(int now)
     {
         int ls=Tree[now].lson,rs=Tree[now].rson;
         for (int i=; i<=; ++i)
         {
             Tree[now].Max[i]=Tree[now].Min[i]=Tree[now].d[i];
             if (ls)
             {
                 Tree[now].Max[i]=max(Tree[now].Max[i],Tree[ls].Max[i]);
                 Tree[now].Min[i]=min(Tree[now].Min[i],Tree[ls].Min[i]);
             }
             if (rs)
             {
                 Tree[now].Max[i]=max(Tree[now].Max[i],Tree[rs].Max[i]);
                 Tree[now].Min[i]=min(Tree[now].Min[i],Tree[rs].Min[i]);
             }
         }
         Tree[now].size=Tree[ls].size+Tree[rs].size+;
     }
     int Build(int opt,int l,int r)
     {
         if (l>r) return ;
         int mid=(l+r)>>,now=NewNode();
         D=opt; nth_element(p+l,p+mid,p+r+);
         Tree[now]=p[mid]; Tree[now].size=;
         Tree[now].lson=Build(opt^,l,mid-);
         Tree[now].rson=Build(opt^,mid+,r);
         Update(now);
         return now;
     }
     int Get_min(int now)
     {
         int ans=;
         for (int i=; i<=; ++i)
         {
             ans+=max(,T.d[i]-Tree[now].Max[i]);
             ans+=max(,Tree[now].Min[i]-T.d[i]);
         }
         return ans;
     }
     void Query(int now)
     {
         ans=min(ans,abs(T.d[]-Tree[now].d[])+abs(T.d[]-Tree[now].d[]));
         int ls=Tree[now].lson,rs=Tree[now].rson,lans=INF,rans=INF;
         if (ls) lans=Get_min(ls);
         if (rs) rans=Get_min(rs);
         if (lans<rans)
         {
             if (lans<ans) Query(ls);
             if (rans<ans) Query(rs);
         }
         else
         {
             if (rans<ans) Query(rs);
             if (lans<ans) Query(ls);
         }
     }
     void Dfs(int now,int sz)
     {
         int ls=Tree[now].lson,rs=Tree[now].rson;
         if (ls) Dfs(ls,sz);
         p[sz+Tree[ls].size]=Tree[now];
         stack[++top]=now;
         if (rs) Dfs(rs,sz+Tree[ls].size+);
     }
     void Check(int &now,int opt)
     {
         int ls=Tree[now].lson, rs=Tree[now].rson;
         if (Tree[ls].size>alpha*Tree[now].size || Tree[rs].size>alpha*Tree[now].size)
         {
             Dfs(now,);
             now=Build(opt,,Tree[now].size);
         }
     }
     void Insert(int &now,int x,int opt)
     {
         if (Tree[x].d[opt]<=Tree[now].d[opt])
         {
             if (Tree[now].lson) Insert(Tree[now].lson,x,opt^);
             else Tree[now].lson=x;
         }
         else
         {
             if (Tree[now].rson) Insert(Tree[now].rson,x,opt^);
             else Tree[now].rson=x;
         }
         Update(now); Check(now,opt);
     }
 }KDT;

 int main()
 {
     scanf("%d%d",&n,&m);
     for (int i=; i<=n; ++i)
     {
         scanf("%d%d",&x,&y);
         p[i].d[]=x; p[i].d[]=y;
     }
     Root=KDT.Build(,,n);
     for (int i=; i<=m; ++i)
     {
         scanf("%d%d%d",&opt,&x,&y);
         if (opt==)
         {
             int t=NewNode();
             KDT.Tree[t]=Node(x,y);
             KDT.Tree[t].size=;
             KDT.Insert(Root,t,);
         }
         else
         {
             T.d[]=x; T.d[]=y; ans=INF;
             KDT.Query(Root);
             printf("%d\n",ans);
         }
     }
 }