[学习笔记] 乱世之神杀疯了 —— K-D tree
文章目录
- K-D tree
- 建树
- 合并
- 插入
- 删除
- 查询(估价函数)
- 旋转坐标系
- 题目练习
-
- [SDOI2012]最近最远点对
- [Violet]天使玩偶/SJY摆棋子
- [CQOI2016]K远点对
- [国家集训队]JZPFAR
- The closest M points
- 简单题
- 巧克力王国
- [BOI2007]Mokia 摩基亚
- [CH弱省胡策R2]TATT
- [BZOJ3815]卡常数
- [NOI2019]弹跳
- A simple rmq problem
- [Ipsc2015]Generating Synergy
- 崂山白花蛇草水
- 数列
- K-D tree 总结
K-D tree
K-D tree \text{K-D tree} K-D tree 是一种对 k k k 维空间中的实例点进行存储以便对其进行快速检索的树形数据结构。
主要应用于多维空间关键数据的搜索。
是二叉搜索树结构。
所以可以用来解决高维偏序问题，可以代替树套树以及 CDQ \text{CDQ} CDQ 分治（一般不容易写挂）。
建树
k − d k-d k−d 树的构造是基于对 K K K 维空间的分割，每次选取其中一维坐标的中位数作为划分界线。
一般循环地以每维坐标为划分依据，把中位数所在点作为该子树的根， 动态开点。
以二维为例（可以展示图片）：
![[学习笔记] 乱世之神杀疯了 —— K-D tree_第1张图片](http://img.e-com-net.com/image/info8/89ca76e6dd44410c8924474dffd85a5f.png)
![[学习笔记] 乱世之神杀疯了 —— K-D tree_第2张图片](http://img.e-com-net.com/image/info8/e27b10fabd46416db697e4438a8aca22.jpg)
![[学习笔记] 乱世之神杀疯了 —— K-D tree_第3张图片](http://img.e-com-net.com/image/info8/e7797cac43fe4e6ab56c97c847a2309c.jpg)
![[学习笔记] 乱世之神杀疯了 —— K-D tree_第4张图片](http://img.e-com-net.com/image/info8/0186db35968646e495a327eda07a4eee.jpg)
时间复杂度 T ( n ) = O ( n ) + T ( n 2 ) = O ( n log n ) T(n)=O(n)+T(\frac n2)=O(n\log n) T(n)=O(n)+T(2n)=O(nlogn)，深度为 O ( log n ) O(\log n) O(logn)。
多维空间存储用结构体，每次选用不同维度的坐标做划分参考，所以我们需要重载坐标点的偏序关系规则（大小比较方式）。
我习惯定义一个全局变量 dim \text{dim} dim，表示当前的维度编号。
bool operator < ( point a, point b ) {
if( dim == 0 ) return a.x < b.x;
if( dim == 1 ) return a.y < b.y;
}
可以用 C++ \text{C++} C++ 库里面自带的 nth_element() O ( n ) O(n) O(n) 求中位数。
nth_element(g+l,g+mid,g+r+1,cmp)：将 g g g 数组的 l ∼ r l\sim r l∼r 区间按照 c m p cmp cmp 方式比较大小，求出第 m i d mid mid 大的点信息。
这个函数只能保证 m i d mid mid 左边的都不大于 m i d mid mid， m i d mid mid 右边的都不小于 m i d mid mid，但不保证其内部仍然有序，即只排序了 m i d mid mid 这一个点。
我习惯重载结构体的大小符号比较，见上，所以就不用写后面的 c m p cmp cmp。
void build( int &now, int l, int r, int d ) {
now = ++ cnt, dim = d;
nth_element( g + l, g + mid, g + r + 1 );
//记录k-d tree上这个点的信息
t[now].Min = t[now].Max = t[now].v = g[mid];
t[now].dim = d, num[t[now].v.id] = now;
t[now].val = t[now].v.val;
if( l < mid ) build( lson, l, mid - 1, d ^ 1 );
if( mid < r ) build( rson, mid + 1, r, d ^ 1 );
pushup( now );
}
由此也可以建出 k k k 维的 k − d k-d k−d 树了。无非是维度循环的更改罢了。(d+1)%k
建树过程中根据题目要求进行信息选择记忆。最后的总结会写到。
合并
与所有二叉搜索树一样， k − d k-d k−d 树也要进行自底向上的信息合并问题。
以二维为例（比较直观能感受）
![[学习笔记] 乱世之神杀疯了 —— K-D tree_第5张图片](http://img.e-com-net.com/image/info8/1ce774c2dea54cff8da0234647403d68.jpg)
![[学习笔记] 乱世之神杀疯了 —— K-D tree_第6张图片](http://img.e-com-net.com/image/info8/ad1f8b04c3e844bd89a62273285bd1ca.jpg)
![[学习笔记] 乱世之神杀疯了 —— K-D tree_第7张图片](http://img.e-com-net.com/image/info8/29634f22bdb548ceaa487f10e11f8c19.jpg)
![[学习笔记] 乱世之神杀疯了 —— K-D tree_第8张图片](http://img.e-com-net.com/image/info8/79e432ece1e34b2c8a5de19876e6c733.jpg)
蓝色是 k − d k-d k−d 树上的自编号，旁边黑色编号表示这个点存储的点的编号。
以根 1 1 1 为例，储存的是编号为 3 3 3 的黑点信息，通过下面给出的合并操作，你会发现其实在 1 1 1 点维护的是一个(Min.x,Min.y)-(Max.x,Max.y) 的矩形。
而这个 M i n . x / M i n . y Min.x/Min.y Min.x/Min.y 是由黑点 1 1 1 提供的， M a x . x Max.x Max.x 是由黑点 6 6 6 提供的， M a x . y Max.y Max.y 是由黑点 2 2 2 提供的，这些信息都是通过合并往上传递的。
在这里再阐述 k − d k-d k−d 树节点的结构体。
struct point { int x, y; };
struct node {
point Min, Max, v;
int lson, rson;
}t[maxn];
//Min即管辖矩形的左下角 Max即管辖矩形的右上角 v是这个k-d tree点储存的实点
void chkmin( point &a, point b ) {
a.x = min( a.x, b.x );
a.y = min( a.y, b.y );
}
void chkmax( point &a, point b ) {
a.x = max( a.x, b.x );
a.y = max( a.y, b.y );
}
void pushup( int now ) {
int lson = t[now].lson, rson = t[now].rson;
if( lson ) {
chkmin( t[now].Min, t[lson].Min );
chkmax( t[now].Max, t[lson].Max );
}
if( rson ) {
chkmin( t[now].Min, t[rson].Min );
chkmax( t[now].Max, t[rson].Max );
}
}
k k k 维无法想象出来，但是可以类比是维护了一个 k k k 维图形。
为了方便码，可以用将维度放到一个数组里面，循环维护。
void pushup( int now ) {
for( int i = 0;i < k;i ++ ) {
if( lson ) {
t[now].Min.d[i] = min( t[now].Min.d[i], t[lson].Min.d[i] );
t[now].Max.d[i] = max( t[now].Max.d[i], t[lson].Max.d[i] );
}
if( rson ) {
t[now].Min.d[i] = min( t[now].Min.d[i], t[rson].Min.d[i] );
t[now].Max.d[i] = max( t[now].Max.d[i], t[rson].Max.d[i] );
}
}
}
貌似看来，二维矩阵里面的计数问题，面积问题，什么的都可以做。甚至多维里面的计数也可以做！
这里的合并只是对管辖区间进行了描边，没有什么内部点权值和，点个数这些信息的更新，视题目自行修改即可。
下面的例题和总结会写到。
插入
由于 k − d k-d k−d 树是二叉搜索树结构，所以插入新的节点可以类比 B S T BST BST 的插入进行。
但随着新的节点的插入， k − d k-d k−d 树将不再平衡。
经典的解决方法是使用替罪羊树：引入一个平衡因子 α \alpha α。对于 k − d k-d k−d 树上的一个结点 x x x，在插入/删除（删除很少重构的）完以后，若其左/右子树的结点数在以 x x x 为根的子树的结点数中的占比大于 α α α，则认为以 x x x 为根的子树是不平衡的，需要重构。
重构时，先遍历子树求出一个序列（中序遍历），然后对这个序列重新建出一棵 k − d k-d k−d 树，代替原来不平衡的子树。即拍扁重构。
但是这个时效性也是不确定的，平衡因子十分的玄乎，具体细节最后总结会写到。
先阅读下方代码，重构需要注意的四大点：
-
void rebuild(int &now)这个 & \& & 细节，很容易写掉。因为要直接替代原来的编号不然就白建。 -
i d id id 是我将子树拍扁后的序列数组。
在重构的寻找中位数函数中，不能不写第四个元素。
不写就变成默认 i d [ u ] , i d [ v ] id[u],id[v] id[u],id[v] 的一维比较了，要比较的是 i d [ u ] , i d [ v ] id[u],id[v] id[u],id[v] 在 k − d k-d k−d 树上储存的点。
-
build(1, tot, t[now].dim)：因为我的写法原因，维数是循环的，重构 n o w now now 的子树，必须从 n o w now now 之前划分的参照维度开始循环。不能一味从 0 0 0 开始，这样后面的维度划分全都错位，丧失了二叉搜索树的有序性质。
-
重构是对编号的重新分配，但每个编号对应的树上点代表的实点仍不变。偏序关系仍是成立的。
int build( int l, int r, int d ) {
if( l > r ) return 0;
dim = d;
nth_element( id + l, id + mid, id + r + 1, []( int a, int b ) { return t[a].v < t[b].v; } );
int now = id[mid]; t[now].dim = d;
t[now].lson = build( l, mid - 1, d ^ 1 );
t[now].rson = build( mid + 1, r, d ^ 1 );
pushup( now );
return now;
}
void dfs( int now ) {
if( ! now ) return;
dfs( t[now].lson );
id[++ tot] = now;
dfs( t[now].rson );
}
void rebuild( int &now ) {
tot = 0;
dfs( now );
now = build( 1, tot, t[now].dim );
}
void insert( int &now, point p, int d ) {
if( ! now ) {
t[now = ++ cnt].siz = 1;
t[now].Max = t[now].Min = t[now].v = p;
t[now].dim = d;
//还需记录的信息视情况而定
return;
}
dim = d;
if( p < t[now].v ) insert( t[now].lson, p, d ^ 1 );
else insert( t[now].rson, p, d ^ 1 );
pushup( now );
if( bad( now ) ) rebuild( now );
}
删除
由于 k-d tree \text{k-d tree} k-d tree 需要保证结构的空间划分性质，所以不能直接使用一些平衡树的删除方式。
可以在删除的节点上保留一个已删除标记，并且从这个点到根自底向上重新合并一遍，从而在它的祖先中抹除它的信息，在进行重构时再真正地删除它。
所以要记录每个实点在 k-d tree \text{k-d tree} k-d tree 上的点编号。
时间复杂度 O ( log n ) O(\log n) O(logn)。
具体代码看例题《卡常数》。
查询(估价函数)
k − d k-d k−d 树的时间复杂度，除了重构，就是这个查询决定了。
估价函数就像 A ∗ A* A∗ 里的一样提前预判。整的那么高级，其实就是剪枝哈哈哈。
因为这个查询如果没有任何简直，那么跟暴力就没啥区别了。
假设要求离一个已知点 p p p 的最远点距离。
如果不设计剪枝，那么跟枚举最远点再算距离没有任何区别。
如果设计剪枝，又怎么设计呢？
我们知道树上一个点会管辖一个维度空间，那么当走到树上某个点时，这个点子树内的点一定都在管辖区间内。
我们大可在该点计算一下 p p p 到这个维度空间的最远距离。（与边框点的距离）
如果算出来的最远距离都小于当前答案就没必要往下继续查了。
（最近点距离就查最近距离）
这里距离视题目而定，欧几里得距离？曼哈顿距离？切比雪夫距离？
看似很无脑的剪枝，但是真的很有用。
如果没有返回，就有可能在这个点的子树内更新距离。
到每个点时，先算一下这个点代表的实点的距离，看能否更新。
然后算 p p p 到这个点左右儿子管辖维度空间的距离。
这里有人设计剪枝是，如果左儿子最大距离更大就先找左儿子，否则先走右儿子。
说实话这个剪枝的时效性是由数据决定的，如果边框点附近有点那么这个剪枝就是很有效的。
加上反正不会错，遇到这种数据那皆大欢喜。所以一般还是可以写这个剪枝。
具体代码见《最近最远点对》。
如果是高维空间内的信息查询问题，就是线段树常解决的，最大值？最小值？内部点个数？内部和？
剪枝设计可类比线段树。考虑查询的高维空间和树上某点的管辖空间。
完全不交，直接返回。
被完全包含，直接返回区间整体信息。
部分交，就继续往左右儿子查询。
模板可见《简单题》。
剪枝各种各样取决于题目所求。
旋转坐标系
假设两个点 ( x 1 , y 1 ) ( x 2 , y 2 ) (x_1,y_1)(x_2,y_2) (x1,y1)(x2,y2)。
曼哈顿距离是横纵坐标差之和，即 ∣ x 1 − x 2 ∣ + ∣ y 1 + y 2 ∣ |x_1-x_2|+|y_1+y_2| ∣x1−x2∣+∣y1+y2∣。
切比雪夫距离是横纵坐标差的较大值，即 max ( ∣ x 1 − x 2 ∣ , ∣ y 1 − y 2 ∣ ) \max(|x_1-x_2|,|y_1-y_2|) max(∣x1−x2∣,∣y1−y2∣)。
看似两种距离没有什么关系。不妨画个图。
考虑最简单的情况，如果用曼哈顿距离表示距离原点为 1 1 1 的所有点会构成边长 2 \sqrt{2} 2 的正方形。
![[学习笔记] 乱世之神杀疯了 —— K-D tree_第9张图片](http://img.e-com-net.com/image/info8/950968dfcfce49d49192a84f8f35ee96.jpg)
如果用切比雪夫距离表示距离原点为 1 1 1 的所有点会构成边长 2 2 2 的边长。
![[学习笔记] 乱世之神杀疯了 —— K-D tree_第10张图片](http://img.e-com-net.com/image/info8/c5325628c48a45dd883afff90a23e881.jpg)
仔细对比两个图形是有一定联系的，我们猜想有固定的方式使得两者可以相互转化。
事实证明的确如此，前人智慧！
- 将点 ( x , y ) → ( x + y , x − y ) (x,y)\rightarrow (x+y,x-y) (x,y)→(x+y,x−y)，则原坐标系中的曼哈顿距离等于新坐标系中的切比雪夫距离。
- 将点 ( x , y ) → ( x + y 2 , x − y 2 ) (x,y)\rightarrow (\frac{x+y}2,\frac{x-y}2) (x,y)→(2x+y,2x−y)，则原坐标系中的切比雪夫距离等于新坐标系中的曼哈顿距离。
切比雪夫距离在计算的时候需要取 max \max max，往往不是很好优化，对于一个点，计算其他点到该的距离的复杂度为 O ( n ) O(n) O(n)。
而曼哈顿距离只有求和以及取绝对值两种运算，把坐标排序后可以去掉绝对值的影响，进而用前缀和优化，可以把复杂度降为 O ( 1 ) O(1) O(1)。
将切比雪夫转化为曼哈顿距离就能将复杂度降下来。
但在 K-D tree \text{K-D tree} K-D tree 中我们反而更喜欢 max \text{max} max 因为这可以成为一个偏序关系。（绝对值打开， − a ≤ x ≤ a -a\le x\le a −a≤x≤a 就是一段区间了）
在图形上来看就是比起斜着的我们更喜欢平行坐标系的图形。
这个就是“旋转坐标系”。
这个旋转通常会在原题上看到绝对值的痕迹。
题目练习
温馨提示：从《弹跳》开始往后都是更灵活的应用，有思维和码力的丢丢要求。之前的都是模板题找感觉。
后面的题目是建立在前面大量模板题的刷题形成的感觉基础上。也不太好解释，但是后面的题目会对前面感觉的纠正与强化。
每道题作者都犯了错
作者是通过《IPSC》一题加强了刻画，以及建树形成的高维空间形象。
作者是通过《崂山白花蛇草水》一题加强了多维空间建树的有序性。
每个人形成的感觉都不一样，所以后面的路只能自己走了。这个高维数据结构不像一维的二叉树可以画图直观感受。
别问为什么那么多模板题，问就是作者菜
[SDOI2012]最近最远点对
洛谷链接
模板题，动态插点，问了再插。
#include [Violet]天使玩偶/SJY摆棋子
洛谷链接
动态插点后，带重构，就只需要求最近的点距离了。
//[Violet]天使玩偶/SJY摆棋子
#include [CQOI2016]K远点对
洛谷链接
K K K 没有多大，可以开一个 K K K 大小的优先队列，不停更新即可。
// [CQOI2016]K远点对
#include [国家集训队]JZPFAR
洛谷链接
动态插点后，略微修改一下偏序比较规则（带上编号），就是上一道题了。
//[国家集训队]JZPFAR
#include The closest M points
K K K 近点对问题。注意，nth_element() 是真的对数组进行了排序调换的。这也是代码里 dot[i] \text{dot[i]} dot[i] 的作用。
#include 简单题
洛谷链接
与二叉树同样的，一个点可以维护整个区间的信息和，查询的估价函数设计板题。
如果查询的矩形与这个树上点管辖的矩形完全不交，就直接返回；
完全包含，就直接加上内部所有点贡献。
如果部分交，就继续往下查。
//简单题
#include 巧克力王国
洛谷链接
算是对上一道题的掌握检查吧。
//巧克力王国
#include [BOI2007]Mokia 摩基亚
洛谷链接
这连续三道题都可以说明 K-D tree \text{K-D tree} K-D tree 是具有高维线段树，二叉搜索树的相同性质和用途的。
#include [CH弱省胡策R2]TATT
洛谷链接
偏序问题的代表。
二维问题，我们通过一次排序使得一维有序，然后可以在树状数组上做查询，使得第二维也有序。
三维问题，就得再套一个 CDQ \text{CDQ} CDQ 了。
四维更是要命！我们直接好码的 k-d tree \text{k-d tree} k-d tree 就可以乱杀。
将所有点按 a a a 排序就已经使得一维有序了，动态插入，查询三维 b , c , d b,c,d b,c,d 内部的点即可。
//[CH弱省胡策R2]TATT
#include [BZOJ3815]卡常数
bzoj链接
延迟删除。
#include [NOI2019]弹跳
洛谷链接
k-d tree \text{k-d tree} k-d tree 的优化建图。
k-d tree \text{k-d tree} k-d tree 的每个节点维护着一个坐标和一个矩形的信息。
把原图上的点就叫做实点，编号范围为 [ 1 , n ] [1,n] [1,n]；树上的节点叫做虚点，编号范围为 [ n + 1 , 2 n ] [n+1,2n] [n+1,2n]。
对于每一个实点，遍历装在这个位置的所有弹跳机。
假设当前弹跳机的时间为 t t t，起点为 u u u，上树查询。
-
对于在树上的一个节点 x x x
- 如果 x x x管辖的矩形完全在弹跳机的目标矩形外，
return。 - 如果 x x x 管辖的矩形完全在弹跳机的目标矩形内，从 u u u 向 x x x 建边，权值为 t t t，
return。 - 两区间交叉情况
- 如果 x x x 维护的实点坐标在目标矩形内，从 u u u 向 x − n x−n x−n 建边，权值为 t t t。
- 递归查询两个儿子
- 如果 x x x管辖的矩形完全在弹跳机的目标矩形外，
-
最后对于 ∀ x ∈ [ 1 , n ] ∀x∈[1,n] ∀x∈[1,n]，从 x + n x+n x+n 向 x x x 建边即可。
但这样建出来直接跑，就等着空间爆死吧~~
我们思考，建边的目的是要知道从一个点出发能到达哪些点，但根据刚才的建图，我们完全可以知道从一个节点出发能到达哪些节点。
- 对于一个虚点 u ( u ∈ ( n , 2 n ] ) u(u\in(n,2n]) u(u∈(n,2n])，能到达的节点：
- 它的两个儿子对应的虚点。
- 它所对应的实点。
- 对于一个实点 u ( u ∈ [ 1 , n ] ) u(u\in[1,n]) u(u∈[1,n])
- 在跑最短路时，如果从队列中拿出实点，直接遍历从 u u u 被代表的树上节点编号出发的弹跳机，上树查询。
- 对于在树上的一个虚点 x ( x ∈ ( n , 2 n ] ) x(x\in(n,2n]) x(x∈(n,2n])
- 如果 x x x 管辖的区间完全在目标区间外，
return - 如果 x x x 管辖的区间完全在目标区间内，松弛 x x x。
- 对于区间部分交情况：
- 如果 x x x 对应的坐标在目标区间内，松弛 x − n x−n x−n。
- 递归查询两个儿子。
- 如果 x x x 管辖的区间完全在目标区间外，
- 松弛时加上的距离即为弹跳机用时。
这完全是一样的！我们不用真的建出边，却能直接走边！
#include A simple rmq problem
BZOJ3489
考虑怎么处理这个“只出现过一次的数“的限制条件。
首先能找到， l ≤ i ≤ r l\le i\le r l≤i≤r。这是一维。
只出现一次？那么上一次就不能出现在 [ l , r ] [l,r] [l,r] 里面，下一次也不能。
记 l s t i : a i lst_i:a_i lsti:ai 上一次出现的位置， n x t i : a i nxt_i:a_i nxti:ai 下一次出现的位置。
我们就又有两个偏序关系了， l s t i < l lst_i
相当于我们要的点 ( x , y , z ) (x,y,z) (x,y,z) 要满足 l ≤ x ≤ r ∧ y < l ∧ z > r l\le x\le r\wedge y
好了三维 K-D tree 直接上。
// A simple rmq problem
#include [Ipsc2015]Generating Synergy
BZOJ4154
如果是将距离 a a a 不超过 l l l 的所有点都染色，可能会简单一点。
现在还多了个限制要求这些该被染的点得是 a a a 子树内部的点。
树上的偏序关系不难想到 dfs \text{dfs} dfs 序。将这些点在树上进行重编号，并记录管辖子树对应的一段连续重编号区间。
这个距离变成树上距离，我们可能会想用深度来做，但是同层隶属不同祖先的距离是不同的，估价函数不好设计很容易超时。而且是染色一堆点，我们肯定要用到懒标记，懒标记的复杂度也跟估价函数设计挂钩。问题就在于怎么设计估价函数，距离用什么估计是最优的？？？
重新读了一遍题目， a a a 子树内与 a a a 距离不超过 l l l，又没让染 a a a 的兄弟旁系亲属。
所以就是用深度来做第二维！这些染色点的深度一定都大于 a a a，且编号都在 a a a 管辖的区间编号内。
因为有懒标记的存在，不能直接从 a a a 开始，而是要从 a a a 开始往上跳父亲找到根，将一路上的标记释放掉才能继续。
染色的时候，就直接从根开始往下走，边走边释放懒标记，遇到在查询刻画出的三维空间内的点就染色/新增懒标记。
切记：原树上 u u u 是 f a fa fa 的儿子不能说明 K D T KDT KDT 上 u u u 的儿子不可能是 f a fa fa。
//[Ipsc2015]Generating Synergy
#include 崂山白花蛇草水
BZOJ4605
带插入、修改的二维区间 k k k 大值在线查询。
先考虑如果就只是问所有点中的 K K K 大值，（离散）权值线段树可做，各种（平衡树）也可以做。
考虑二叉搜索树是满足左边的权值都不大于自己，右边权值都不小于自己。
然后用 siz 来锐减 K，只用 O(log )的时间。
这里我们直接类比，K 大值就是找 K 个，查询同样用 siz 来做。
在刻画出来的二维图形内进行类似平衡树的操作，左右子树 siz 判断走左子树还是右子树，继续搜还是减子树个数直接返回劈里啪啦。
第 K 大先走右儿子再走左儿子。
以上都是错的——因为 K D T KDT KDT 只保证当前划分参照维度是有序的。（说到底该层也只是一维平衡树）
直接在二分第 K K K 大的值，然后在 K D T KDT KDT 上查刻画空间内值比二分值大的个数有多少个，调整即可。
线段树套KDT的是觉得二分短小精悍作用相同不香吗？
#include 数列
BZOJ2898
啊看 ∣ x − y ∣ + ∣ a x − a y ∣ |x-y|+|a_x-a_y| ∣x−y∣+∣ax−ay∣ ，绝对值欸！直接旋转坐标系 ( i , a i ) → ( i + a i , i − a i ) (i,a_i)\rightarrow (i+a_i,i-a_i) (i,ai)→(i+ai,i−ai)。
询问就变成了点 ( x + a x , x − a x ) (x+a_x,x-a_x) (x+ax,x−ax) 与点 ( i + a i , i − a i ) (i+a_i,i-a_i) (i+ai,i−ai) 的切比雪夫距离 ≤ k \le k ≤k 的 i i i 的数量。
即在新坐标系上的点 ( x , y ) (x,y) (x,y) 到指定点 ( x 0 , y 0 ) (x_0,y_0) (x0,y0) 需要满足 ∣ x − x 0 ∣ ≤ k ∧ ∣ y − y 0 ∣ ≤ k |x-x_0|\le k\wedge|y-y_0|\le k ∣x−x0∣≤k∧∣y−y0∣≤k。
直接拆开 − k + x 0 ≤ x ≤ k + x 0 ∧ − k + y 0 ≤ y ≤ k + y 0 -k+x_0\le x\le k+x_0\wedge -k+y_0\le y\le k+y_0 −k+x0≤x≤k+x0∧−k+y0≤y≤k+y0，这不就是个矩形了吗？
这不就转化成了矩形内计数问题了？
又要考虑历史版本，直接把时间也弄成一维偏序。
问题就变成三维 K D T KDT KDT 计数问题了。一下子简单了好多。
当然可以在线做，就让时间自然有序，写个动态插入重构也行。
#include K-D tree 总结
K-D tree 就是用来解决多维问题下的偏序关系的。在不考虑时间的情况下按道理是可以通用乱杀的。
这个偏序关系涉及得就多了去了，只要能找到偏序关系都行。或者说 CDQ 的题我都能硬套 K-D tree？！
想办法硬套出一个偏序关系，多套几个越能感受到 K-D tree \text{K-D tree} K-D tree 的好，代码也几乎不变， CDQ \text{CDQ} CDQ 就越套越多了。
找出代替原问题的偏序关系，将成为写 K-D tree \text{K-D tree} K-D tree 的强力保障。
K-D tree 虽然时间非常玄乎，但是大多数时候都可以被当成和分块一样的优雅暴力而被世人（博主）传颂。
数据结构套路多多，这个就很难写挂。
所以遇到三维及以上的问题，我不会 CDQ \text{CDQ} CDQ 不如直接 K-D tree \text{K-D tree} K-D tree 硬刚。
不求全过，但是拿大部分分也是很优秀的了。
比基础暴力分高的都是好做法——by博主。
对于 K-D tree \text{K-D tree} K-D tree 的理解，可以想象成平衡树套平衡树套平衡树无限嵌套，那么对于一些应用就可以仿照这些数据结构的写法。
K D T KDT KDT 的划分维度仅仅保证了区间的那一维上是有序的，其余维度是无序的。
换言之，每到新的一层 [ l , r ] [l,r] [l,r] 相当于按照 d d d 维为偏序构造了个平衡树，其余维度的偏序是不被保证的。
所以要么里面嵌套权值线段树《崂山白花蛇水草》等各种，要么扩展一维新的偏序关系。
常见的使用：
-
套替罪羊树，设计平衡因子，排扁重构。
平衡因子是比较玄学的一个部分。
一般而言，可以先敲一个不重构的版本，过了就不管了，没过再来加重构。
平衡因子 （作者喜欢的范围：
0.75~0.985） 决定于数据。如果 n n n 比较小一般不用重构都能过，可以以 1 e 5 1e5 1e5 做参考。
要知道平衡因子越小（越接近 0.5 0.5 0.5 要求绝对平衡）重构的次数就越多，时间消耗也会越大。
所以一般会让其适当的倾斜。
-
涉及动态插入和删除。
删除并不是及时删除，而是打上标记，延后删除，利用向上合并不要这个点的信息来做到抹除这个点。
这个向上合并是要从该点开始往上一路的祖先都要重新维护新信息。
动态一个一个插入时效性不及整个序列一次性建树优秀。（尤其是还带了重构的动态插入）
-
估价函数（即在查询中的剪枝设计）
一般设计分为三个部分，完全无关，全部包含，仅交一部分。
前两者就可以直接在该点得到所有信息，返回；最后一个要继续往下递归下去。
每次还要考虑当前点的贡献。
查询一定是从 K-D tree \text{K-D tree} K-D tree 的树根开始往下查，根据询问刻画出的多维空间来判断每个点具体的贡献。
不能直接跳到 K-D tree \text{K-D tree} K-D tree 上某些点直接往下做。
《IPSC》这道题就不能直接从 a a a 在 K-D tree 上对应的点开始往下做。
谁能保证 a a a 原树的子树内部的点在 K D T KDT KDT 上一定也是对应点子树内的呢？
-
优化建图。
同线段树优化建图一样。一段连续区间用一个点来表示，就不需要太多的废边。
线段树是一维的，只能是一段连续区间。 K D T KDT KDT 就是多维的，一个矩阵就可被视为二维连续区间。
理解可以想成高维线段树。
大多数题目的差别其实就是体现在维度的个数，估价函数随题目要求不同而设计的不同，根据题目要求设定的偏序关系。
当你毫无思路的时候，不妨想想随机化偏分，网络流和k-d tree——by作者。