从K-D tree到……

提到KD Tree就想到陌上花开，提到陌上花开就想到CDQ分治，提到CDQ分治就发现我不会CDQ了……那就先复习一下CDQ吧

陌上花开

三维空间内n个元素，每个元素表示为（$a_i$, $b_i$, $c_i$），求每个点有多少个点在它的左下后方，即（$a_j\le a_i$, $b_j\le b_i$, $c_j\le c_i$ ）。

CDQ分治

有两种方法：

1. CDQ+树状数组
2. CDQ套CDQ

CDQ 加树状数组

• 按照x维度进行sort
• 分治
  • 每次将当前序列S(l, r)分割为A(l, mid)和B(mid + 1, r)
  • 分别递归处理A、B段，再考虑A和B之间的关系
  • 对于两段分别按照y维度进行sort
    • 此时，A段的x均小于（等于）B段，并且A、B两端分别在y上是有序的
    • 接下来就是对于B段的每一个元素b，找到A段中在y维度上小于等于b的最右的元素a，查看a及a的左边有多少个元素在z维度上满足小于b
  • 在B段从左向右枚举b，对应在A段放置一个指针a指向满足在y上小于等于b的最右的元素a。
    • 由于b从左向右移动，所以a必然也是从左向右单向移动的
  • 指针a每次移动时，将对应位置的元素按照z维度放置在树状数组内
  • 对于每一个b，查询当前树状数组内z维度上有多少个比b小的，添加到统计中
  • 【重要】递归回溯时，需要删去这个过程中树状数组内的值，以免对下一层递归产影响

细节

• 处理重复元素：将重复元素合并，最终记录结果时应当加上（重复数-1），因为重复元素之间互为等于

伪代码

Function CDQ (S, F) 
    # 分割序列S为A、B
	mid = len(S) / 2
    A = S[1...mid]
    B = S[mid+1...len(S)]
    
    # 分别处理 A、B序列
    CDQ(A)
    CDQ(B)
     
	# 按照y维度分别对A、B进行排序
    F = sort(A, cmpy, F)
    F = sort(B, cmpy, F)
        
    # 设定指针a
    a = 1
    # 枚举B中每个b
    for(b=1 to len(B))
     	while (a <= len(A) and A[a].y <= B[b].y)
     		# 插入树状数组，其中cnt表示重复数
     		BiTree.add(A[a].z, A[a].cnt)
     		i++
     	End
     	# 当前树状数组中的值均满足x和y维度上小于b，只需要再查询树状数组中有多少z维度上小于b的就好了
     	F[B[b].id] += BiTree.query(B[b].z)
    End
    for (a=1 to len(A))
    	BiTree.add(A[a].z, -A[a].cnt)
    End
    return F
 End
 
 Function main(S) 
 	# 按照x排序
 	sort(S, cmpx)
 	# 合并重复数
 	S = merge(S)
 	F = CDQ(S)
 	for (i=1 to len(S))
 		ans[F[S[i].id] + S[i].cnt - 1] += S[i].cnt #注意此处需要考虑重复元素
 	return F 
 	
 End

陌上花开C代码

#include
#include
#include
#include
#include
#include
using namespace std;
struct apple{
	int x,y,z,c,id;
	apple(){}
	apple(int a,int b,int m,int n,int p)
	{
		x=a;y=b;z=m;c=n;id=p;
	}
}node[100010],no[100010];
int tree[200010],f[100010],ff[100010];
int m;
bool cmpx(apple a,apple b)
{
	return a.x0;i-=lowbit(i))
		ans+=tree[i];
	return ans;
}
void add(int x,int z)
{
	for(int i=x;i<=m;i+=lowbit(i))
		tree[i]+=z;
} 
void cdq(int l,int r)
{
	if(l==r)
		return;
	int midd=(l+r)>>1;
	cdq(l,midd);
	cdq(midd+1,r);
	sort(no+l,no+midd+1,cmpy);
	sort(no+midd+1,no+r+1,cmpy);
	int i,j,ans;
	i=l;
	for(j=midd+1;j<=r;j++)
	{
		while(i<=midd&&no[i].y<=no[j].y)
		{
			add(no[i].z,no[i].c);
			i++;
		}
		f[no[j].id]+=query(no[j].z);
	 } 
	 for(j=l;j1&&node[i].x==node[i-1].x&&node[i].y==node[i-1].y&&node[i].z==node[i-1].z)
			no[nn].c++;
		else
		{
			nn++;
			no[nn]=apple(node[i].x,node[i].y,node[i].z,1,nn);
		}
	}
	cdq(1,nn);
	for(i=1;i<=nn;i++)
		ff[f[no[i].id]+no[i].c-1]+=no[i].c;
	for(i=0;i

CDQ套CDQ

• 按照x维度进行sort
• 分治1
  • 每次将当前序列S(l, r)分割为A(l, mid)和B(mid + 1, r)
  • 分别递归处理A、B段，再考虑A和B之间的关系
  • 对于两段按照y进行归并排序得到新的S,但是对于来自A的元素标记flag为1,对于来自b的元素标记flag为0
  • 对新的S进行分治2
• 分治2
  • 每次将当前序列S(l, r)分割为A(l, mid)和B(mid + 1, r)
  • 分别递归处理A、B段，再考虑A和B之间的关系
  • 对z维度进行归并,归并的过程中,我们可以知道A中的元素在y上是小于等右边的,归并过程中双指针分别指向B中的b和A中比b小的最右端的a
  • 遇到a或者b的flag为0时,需要将目前归并得到的所有flag为1的加入到它的答案中去

相关题解: 题解 P3810 【模板】三维偏序 Shadows的博客

KD Tree

简单题

P4148 简单题

先来一道模板题。给一个N*N棋盘，两种操作：

1. 将一个格子中的数值加上k
2. 求一个矩形内所有数的和

强制在线，需要异或前面的答案。

如果不是强制在线，可以将时间作为第三维，进行CDQ分治。

但是强制在线只能KD Tree。

KD Tree的build

与动态线段树的build相同，只不过每次考察的是不同维度。注意每一个点有两组值，分别表示的是原始这个点的坐标，和这个点以下子树做代表的一个矩形的左上和右下。注意向上update，更新父节点的矩形。

KD Tree的query

1. 当前点所代表的矩形在要求范围内，则整个加入
2. 当前点所代表的矩形与要求范围没有交集，则回溯
3. 当前点所代表的矩形与要求范围有交集：
   1. 先判断当前点是否在要求范围内
   2. 递归左右子树

细节

如果失衡，需要把树还原成一个序列，然后重新建树

KD Tree解决陌上花开

首先，直观的思想是将z作为时间，然后利用x和y维度建KD Tree。但是有一个问题，相等的点无法处理。我们举一个情况：

a（1， 2， 3）和b（3， 5， 3）的时候，是可以成功判断出$a\le b$的，但是如果a 在b的后面，我们发现就会漏掉这个答案。

解决办法是，在遍历到某一个点的时候，在包含此前所有点的大KD tree之外，将所有和它在z上相等的点捞出来，单独建一棵小KD Tree，同时查询两颗KD tree。然后将z相同的点都处理好后，将这一批z相同的点统一加入到大KD tree中。

题解 P3810 【模板】三维偏序（陌上花开）[demonovo 的博客]

时间复杂度

二维KD Tree

建树：$nlogn$

增删：$logn$

超方体查询：$\sqrt{n}$

kd-tree(KDT) 时间复杂度证明 q779

KNN

K Nearest Neighbors，最近的K个邻居

非参 惰性

对于一个样本，取其最近的K个（K一般为奇数）点，以这K个点中的多数点的类别为这个样本的预测。一般以欧几里得距离作为衡量标准。K值的选择尤为重要。

KNN算法（一） KNN算法原理 _风凌天下

朴素版KNN

以下代码来自 KNN和KdTree算法实现 zoukankan

def predict(self, X):
    
    knn_list = []
    # 先取出k的点
    for i in range(self.n):
		# linalg = linear + algebra
    	# linalg.norm相关介绍：https://blog.csdn.net/silent1cat/article/details/120811844
        dist = np.linalg.norm(X - self.X_train[i], ord=self.p)
        knn_list.append((dist, self.y_train[i]))
	# 考虑剩下的点，是否有比已经选中的k个点更近的，如果有，则更新这k个点的序列
    for i in range(self.n, len(self.X_train)):
        # 取出当前k个点中距离最大的一个的位置
        max_index = knn_list.index(max(knn_list, key=lambda x: x[0]))
  		# 计算当前点的距离
        dist = np.linalg.norm(X - self.X_train[i], ord=self.p)
        # 如果当前点比最大的一个点近，则替换掉最大的点
        if knn_list[max_index][0] > dist:
            knn_list[max_index] = (dist, self.y_train[i])

    # 统计
    knn = [k[-1] for k in knn_list]
    return Counter(knn).most_common()[0][0]

KD Tree版KNN

以下代码来自 KNN和KdTree算法实现 zoukankan

# 建立kdtree
def create(self, dataSet, label, depth=0):
    if len(dataSet) > 0:
        m, n = np.shape(dataSet)
        self.n = n
        # 当前层的维度
        axis = depth % self.n
        # 按照当前维度排序
        dataSetcopy = sorted(dataSet, key=lambda x: x[axis])
        # 取中点
        mid = int(m / 2)
        node = Node(dataSetcopy[mid], label[mid], depth)
        # 如果是最顶层，需要记录树根
        if depth == 0:
            self.KdTree = node
        # 递归构建左右子树
        node.lchild = self.create(dataSetcopy[:mid], label, depth+1)
        node.rchild = self.create(dataSetcopy[mid+1:], label, depth+1)
        return node
    return None

# 搜索kdtree的前count个近的点
def search(self, x, count = 1):
    nearest = [] # 存储最近的k个点按照距离递减
    # 初始化k个占位点
    for i in range(count):
        nearest.append([-1, None])
    self.nearest = np.array(nearest)

    def recurve(node):
        if node is not None:
            # 计算当前维度
            axis = node.depth % self.n
            # 计算测试点和当前点在当前维度上的差
            daxis = x[axis] - node.data[axis]
            # 如果小于进左子树，大于进右子树
            if daxis < 0:
                recurve(node.lchild)
            else:
                recurve(node.rchild)
            # 计算预测点x到当前点的距离dist
            dist = np.sqrt(np.sum(np.square(x - node.data)))
            for i, d in enumerate(self.nearest):
                # 如果有比现在最近的n个点更近的点，更新最近的点
                if d[0] < 0 or dist < d[0]:
                    # 插入第i个位置的点
                    self.nearest = np.insert(self.nearest, i, [dist, node], axis=0)
                    # 删除最后一个多出来的点
                    self.nearest = self.nearest[:-1]
                    break

            # 统计距离为-1的个数n
            n = list(self.nearest[:, 0]).count(-1)
            '''
            self.nearest[-n-1, 0]是当前nearest中已经有的最近点中，距离最大的点。
            self.nearest[-n-1, 0] > abs(daxis)代表以x为圆心，self.nearest[-n-1, 0]为半径的圆与axis
            相交，说明在左右子树里面有比self.nearest[-n-1, 0]更近的点
            '''
            if self.nearest[-n-1, 0] > abs(daxis):
                if daxis < 0:
                    recurve(node.rchild)
                else:
                    recurve(node.lchild)

    recurve(self.KdTree)

    # nodeList是最近n个点的
    nodeList = self.nearest[:, 1]

    # knn是n个点的标签
    knn = [node.label for node in nodeList]
    return self.nearest[:, 1], Counter(knn).most_common()[0][0]

K-means

【机器学习】K-means 阿泽

1. 随机指定K给中心。
2. 对于每一个点，分别计算这个点到K个中心的距离，并选取最近的中心作为它的聚类中心。
3. 对于每一个中心，计算属于它的所有点的中心位置，以这个新的位置取代中心。
4. 重复2、3直到终止条件达成

伪代码

随机生成k个中心a
while(终止条件)
	for(i=1 to n)
		计算i到每个中心距离，并以最近的作为i的聚类中心
	End
	for (j=1 to k)
		用以中心j为聚类中心的点的中心位置取代中心j
	End
End

ball tree

1. 找到空间中最远的两个点，作为观测点
2. 将其他点按照距离划归到两个观测点中的一个
3. 确定两个观测点所代表的子簇的圆心半径
4. 递归重复上述步骤，直到簇内只有一个点

KNN的核心算法kd-tree和ball-tree 吴智深

LSH 局部敏感哈希

locality-sensetive hashing

哈希：减少冲突

局部敏感哈希：利用哈希冲突加速检索

LSH 的设计思想：如果两点距离较近，它们的哈希值大概率相同；反之则大概率不同。

设小半径$r_1$，大半径$r_2$，近似概率$p_1$，疏远概率$p_2$

若$p\in B(q,r_1)$，则$P_{r_H}[h(q) = h§] \geq p_1 $

若$p\notin B(q,r_2)$，则$P_{r_H}[h(q) = h§] \leq p_2 $

局部敏感哈希（LSH）越前浩波

Locality-Sensitive Hashing: a Primer

PQ （product quantization）

论文Product quantization for nearest neighbor search Herve Jegou, Matthijs Douze, Cordelia Schmid

理解 product quantization 算法 vividfree