【BZOJ2648】【kd_tree】SJY摆棋子

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

HINT

 

 

kdtree可以过

【分析】

大家都知道kd_tree是什么吧，恩

就这样了..好吧，kd_tree一种空间树..看代码就知道了

 /*
 唐代李白
 《江夏别宋之悌》
 楚水清若空，遥将碧海通。人分千里外，兴在一杯中。
 谷鸟吟晴日，江猿啸晚风。平生不下泪，于此泣无穷.
 */
 #include <iostream>
 #include <cstdio>
 #include <algorithm>
 #include <cstring>
 #include <vector>
 #include <utility>
 #include <iomanip>
 #include <string>
 #include <cmath>
 #include <queue>
 #include <assert.h>
 #include <map>
 #include <ctime>
 #include <cstdlib>
 #include <stack>
 #include <set>
 #define LOCAL
 const int INF = 0x7fffffff;
 const int MAXN =   + ;
 const int maxnode =  *  +  * ;
 const int MAXM =  + ;
 const int MAX = ;
 using namespace std;
 struct Node{//kd_tree
    int d[], l, r;
    int Max[], Min[];
 }t[ + ],tmp;

 int n,m,root,cmp_d;
 int k1, k2, k3, Ans;

 bool cmp(Node a, Node b){return (a.d[cmp_d]<b.d[cmp_d]) || ((a.d[cmp_d] == b.d[cmp_d]) && (a.d[!cmp_d] < b.d[!cmp_d]));}
 void update(int p){
      if (t[p].l){
         //左边最大的横坐标值
         t[p].Max[] = max(t[p].Max[], t[t[p].l].Max[]);
         t[p].Min[] = min(t[p].Min[], t[t[p].l].Min[]);
         t[p].Max[] = max(t[p].Max[], t[t[p].l].Max[]);
         t[p].Min[] = min(t[p].Min[], t[t[p].l].Min[]);
      }
      if (t[p].r){
         t[p].Max[] = max(t[p].Max[], t[t[p].r].Max[]);
         t[p].Min[] = min(t[p].Min[], t[t[p].r].Min[]);
         t[p].Max[] = max(t[p].Max[], t[t[p].r].Max[]);
         t[p].Min[] = min(t[p].Min[], t[t[p].r].Min[]);
      }
      return;
 }
 //d是横竖切..
 int build(int l, int r, int D){
     int mid = (l + r) / ;
     cmp_d = D;
     //按照cmp的比较顺序在l到r中找到第mid大的元素
     nth_element(t + l + , t + mid + , t + r + , cmp);
     t[mid].Max[] = t[mid].Min[] = t[mid].d[];
     t[mid].Max[] = t[mid].Min[] = t[mid].d[];
     //递归建树
     if (l != mid) t[mid].l = build(l, mid - , D ^ );
     if (r != mid) t[mid].r = build(mid + , r, D ^ );
     update(mid);
     return mid;
 }
 void insert(int now){
      int D = , p = root;//D还是表示方向
      while (){
            //边下传边更新
            t[p].Max[] = max(t[p].Max[], t[now].Max[]);
            t[p].Min[] = min(t[p].Min[], t[now].Min[]);
            t[p].Max[] = max(t[p].Max[], t[now].Max[]);
            t[p].Min[] = min(t[p].Min[], t[now].Min[]);
            //有没有点线段树的感觉..
            if (t[now].d[D] >= t[p].d[D]){
               if (t[p].r == ){
                  t[p].r = now;
                  return;
               }else p = t[p].r;
            }else{
               if (t[p].l == ){
                  t[p].l = now;
                  return;
               }else p = t[p].l;
            }
            D = D ^ ;
      }
      return;
 }
 int ABS(int x) {return x < ? -x : x;}
 //dist越小代表越趋近？
 int dist(int p1, int px, int py){
     int dist = ;
     if (px < t[p1].Min[]) dist += t[p1].Min[] - px;
     if (px > t[p1].Max[]) dist += px - t[p1].Max[];
     if (py < t[p1].Min[]) dist += t[p1].Min[] - py;
     if (py > t[p1].Max[]) dist += py - t[p1].Max[];
     return dist;
 }
 void ask(int p){
    int dl, dr, d0;
    //哈密顿距离
    d0=ABS(t[p].d[] - k2) + ABS(t[p].d[] - k3);
    if(d0 < Ans) Ans = d0;
    if(t[p].l) dl = dist(t[p].l, k2, k3); else dl = 0x7f7f7f7f;
    if(t[p].r) dr = dist(t[p].r, k2, k3); else dr = 0x7f7f7f7f;
    //应该是一个启发式的过程。
    if(dl < dr){
        if(dl < Ans) ask(t[p].l);
        if(dr < Ans) ask(t[p].r);
    }else{
        if(dr < Ans) ask(t[p].r);
        if(dl < Ans) ask(t[p].l);
    }
 }

 void init(){
      //假设0为横坐标
      scanf("%d%d", &n, &m);
      for (int i = ; i <= n; i++)
      scanf("%d%d", &t[i].d[], &t[i].d[]);
      root = build(, n, );
 }
 void work(){
      for (int i = ; i <= m ;i++){
          scanf("%d%d%d", &k1, &k2, &k3);
          if (k1 == ){//黑棋
             ++n;
             t[n].Max[] = t[n].Min[] = t[n].d[] = k2;
             t[n].Max[] = t[n].Min[] = t[n].d[] = k3;
             insert(n);
          }else{
             Ans = 0x7f7f7f7f;
             ask(root);
             printf("%d\n", Ans);
          }
      }
 }

 int main(){

    init();
    work();
    return ;
 }