【ybt金牌导航4-2-1】【luogu P4169】[Violet]天使玩偶 / SJY摆棋子（K-D tree 模板）
[Violet]天使玩偶 / SJY摆棋子
题目链接：ybt金牌导航4-2-1 / luogu P4169
题目大意
初始有一些点，分布在二维平面上。
然后要你进行一些操作：再往上面放一个点，或者给你一个坐标，找到距离它最近的点到它的距离。
（这里的距离是哈密顿距离，就 x,y 坐标差的和）
思路
这道题我们用 K-D tree 来做。
（它其实可以说是 K-D tree 的模板题？）
那就来略讲一下 K-D tree。
K-D tree 就是一个可以存 \(k\) 维的点一个二叉树。
然后你这个 K-D tree 就相当于对这些点构成的 \(k\) 维空间的一个划分，树中每个点代表一块空间。
而这道题中我们用的是二维 K-D tree，一般用到的也是这个。
它大概是这样，每个深度有一个划分的维度 \(d\)，然后在这个深度的点中，它的左儿子的 \(d\) 维信息小于它的，它右儿子的 \(d\) 维信息大于它的。
那很容易看出你划分的维度当然是轮流来的，就比如先第一维，接着第二维，然后第三维，再变成第一维，以此类推。
（不过说一开始轮的顺序也可以按方差从大到小排，可以缩小时间）
然后划分的依据，容易想到我们要让树尽可能平衡，那我们构树的时候就选中位数作为代表的点，然后再把其他点分到左右两边。（可以用 nth-element）
然后容易看出它是可以不断新放别的点的，就按照每个点，从根节点一直往下走，走到没有点的地方就放在那里。
但是你会想到放多了它可能就不平衡了，那就用替罪羊的思想，也搞个失衡的值。
如果两个子树有一个的个数超过它的个数乘上这个值，就把这个树拍扁重构。
那搞到这一题大概就是你每个点代表一个矩形，而且每个点在树上都有一个代表的点。
然后对于这个节点代表的点，我们求出它到询问给出点的距离。
然后再搞出它两个儿子代表的矩阵到询问点的最短距离。
那这个距离就是这个矩阵里面的点到这个询问点距离的下界，那如果这个下界都比你当前的答案大，那就没有必要跑这个矩阵里面的点了。
（算点到矩阵距离大概就是看四条边，点到四条边的距离）
然后还有一个优化就是，我们可以先跑下界小的矩阵，再跑下界大的。
因为这样答案会更新的更小一点，就可以跳过更多的矩阵。
然后大概这样就好了。
（主要是实现烦）
代码
#include<cstdio>
#include<iostream>
#include<algorithm>
#define INF 1e9
#define alph (0.7)//这个是判断不平衡的（类似替罪羊）
#define rr register
using namespace std;
struct zb {
int w[2];
}a[1000001], tmp;
struct node {
zb a;
int l, r, ma[2], mi[2], size;
}tree[1000001];
int n, m, op, root, tot, ans;
int rebuild[1000001], WD;
int read() {
int re = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
re = (re << 3) + (re << 1) + c - '0';
c = getchar();
}
return re;
}
void write(rr int now) {
if (now > 9) write(now / 10);
putchar(now % 10 + '0');
}
int operator <(zb x, zb y) {//这个是用来作为 nth-element 函数比较的依据的
return x.w[WD] < y.w[WD];
}
int get_point() {//开一个新的点
if (rebuild[0]) return rebuild[rebuild[0]--];//如果是重构就把重构的点拿出来
return ++tot;
}
int abss(rr int now) {
if (now < 0) return -now;
return now;
}
int up(rr int now) {//上传值：坐标最大，最小（其实就是哪个矩阵的位置），里面点的个数
for (int i = 0; i < 2; i++) {
tree[now].mi[i] = tree[now].a.w[i];
tree[now].ma[i] = tree[now].a.w[i];
if (tree[now].l) {
tree[now].mi[i] = min(tree[now].mi[i], tree[tree[now].l].mi[i]);
tree[now].ma[i] = max(tree[now].ma[i], tree[tree[now].l].ma[i]);
}
if (tree[now].r) {
tree[now].mi[i] = min(tree[now].mi[i], tree[tree[now].r].mi[i]);
tree[now].ma[i] = max(tree[now].ma[i], tree[tree[now].r].ma[i]);
}
}
tree[now].size = tree[tree[now].l].size + tree[tree[now].r].size + 1;
}
int build(rr int l, rr int r, rr int wd) {
if (l > r) return 0;
rr int now = get_point();
rr int mid = (l + r) >> 1;
WD = wd;
nth_element(a + l, a + mid, a + r + 1);
tree[now].a = a[mid];//把中间那个搞出来
tree[now].l = build(l, mid - 1, wd ^ 1);
tree[now].r = build(mid + 1, r, wd ^ 1);
up(now);
return now;
}
void make_again(rr int root, rr int num) {//拍扁
if (tree[root].l) make_again(tree[root].l, num);
a[num + tree[tree[root].l].size + 1] = tree[root].a;
rebuild[++rebuild[0]] = root;
if (tree[root].r) make_again(tree[root].r, num + tree[tree[root].l].size + 1);
}
void check(rr int &root, rr int wd) {
if (alph * tree[root].size < tree[tree[root].l].size || alph * tree[root].size < tree[tree[root].r].size) {//不平衡了
make_again(root, 0);//拍扁
root = build(1, tree[root].size, wd);//重构
}
}
void insert(rr zb now, rr int &root, rr int wd) {//插入点
if (!root) {//已经找到位置了
root = get_point();
tree[root].a = now;
tree[root].l = tree[root].r = 0;
up(root);
return ;
}
if (tree[root].a.w[wd] < now.w[wd])//判断它应该放到哪边
insert(now, tree[root].r, wd ^ 1);
else insert(now, tree[root].l, wd ^ 1);
up(root);
check(root, wd);
}
int get_dis(rr zb x, rr zb y) {//求哈密顿距离
return abss(x.w[0] - y.w[0]) + abss(x.w[1] - y.w[1]);
}
int blog_dis(rr zb x, rr int now) {//求一个点到一个矩阵的哈密顿距离
rr int re = 0;
for (int i = 0; i < 2; i++) {
re += max(0, tree[now].mi[i] - x.w[i]);//分别从这个矩阵这个维度的两个（边）
re += max(0, x.w[i] - tree[now].ma[i]);
}
return re;
}
void get_close(rr zb now, rr int root) {//找到距离这个点最近的点
ans = min(ans, get_dis(now, tree[root].a));//先跟中位数代表的点算距离
rr int ldis = INF, rdis = INF;
if (tree[root].l) ldis = blog_dis(now, tree[root].l);
if (tree[root].r) rdis = blog_dis(now, tree[root].r);
if (ldis < rdis) {//先搜答案下界小的（搜之前还要判断是否可能比答案小）
if (ldis < ans) get_close(now, tree[root].l);
if (rdis < ans) get_close(now, tree[root].r);
}
else {
if (rdis < ans) get_close(now, tree[root].r);
if (ldis < ans) get_close(now, tree[root].l);
}
}
int main() {
// freopen("read.txt", "r", stdin);
// freopen("write.txt", "w", stdout);
n = read();
m = read();
for (rr int i = 1; i <= n; i++) {
a[i].w[0] = read();
a[i].w[1] = read();
}
root = build(1, n, 0);
while (m--) {
op = read();
tmp.w[0] = read();
tmp.w[1] = read();
if (op == 1) {
insert(tmp, root, 0);
}
else {
ans = INF;
get_close(tmp, root);
write(ans);
putchar('\n');
}
}
return 0;
}
