关于B-K tree与k-d tree一些自己想法

最新推荐文章于 2025-03-09 15:44:27 发布
最新推荐文章于 2025-03-09 15:44:27 发布
阅读量2.4k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 思考&证明 数据结构 实验室学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/gyarenas/article/details/45622459
本文探讨了B-K树和k-d树的相似之处，两者都用于寻找目标点附近的点。B-K树适用于给定距离k以内的查询，而k-d树则针对最近的k个点。B-K树在数据点距离范围大但k值小时效果显著，常用于单词纠错。k-d树需要数据点有向量描述，建树、插入、删除和查询复杂度分别为O(K*nlgn)、O(K*logn)、O(K*lgk*T)。高维情况下，可以使用BBF优化提高查询效率。虽然在低维中效果有限，但在高维时表现更佳。B-K树与k-d树在一定条件下可以相互模拟。文章提供了二维曼哈顿距离的测试题目，说明BBF优化在低维场景下效果不明显。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

以前用B-K tree做过一个题，最近学习k-d tree，感觉这两个树有某些相似，这个俩种树都是寻找距目标点临近最近的点(B-K tree针对给定距离k以内，k-d tree针对给定最近的k个点)。

其中B-K tree只要求数据点之间定义可度量的距离，支持求距给定点距离k以内的数据点。相对于暴力法来说，是常数级别的提高，但有时会很有效（比如数据点之间距离范围很大，但阀值k很小），一个应用就是实现单词纠错程序。当距离范围较大时，还可以采用分段映射来实现。

k-d tree除了要求数据点之间定义可度量距离外，还要求数据点用向量来描述(因为要按照不同维度进行划分)。建树时间复杂度为O(K*nlgn)，插入和删除都为O(K*logn)，查询k临近为O(K*lgk*T)，其中T为一次查询访问点数量，T最差为O(n^(1-1/k))。维数较高时，效率明显下降，所以又有了BBF优化，大概就是把存储路径上节点的堆栈换成优先队列，按照点距区域距离最短优先的回溯并更新最近点，当队列为空或者当前最近点距离小于对队首权重时即为答案。如果不要求解的最优性，可以通过提前返回的方式以更高的效率得到较优解。


在不考虑效率的情况下，B-K tree可以通过倍增二分的方法实现k-d tree的功能，如果数据点用向量描述，k-d tree也可以实现B-K tree的功能。

附上一道测试题目，二维曼哈顿距离，注释掉的代码为bbf优化，效率只提升了一点，看来bbf优化要在较高维度才有显著效果。

http://www.lydsy.com/JudgeOnline/problem.php?id=2648


<span style="font-size:14px;">#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <utility>
#include <cstring>
#include <map>
#include <climits>
#include <queue>
using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned UI;

const int MAXN(500010);
const int MAXK(100010);
const int MAXL(10);
const int MAXC(2);
const int INF((INT_MAX-1)/2);
const int F(0);

template<typename T>
inline bool checkmax(T &a, const T &b){
    return b > a? ((a = b), true): false;
}

template<typename T>
inline bool checkmin(T &a, const T &b){
    return b < a? ((a = b), true): false;
}

template<typename T>
inline T ABS(T a){
    return a < 0? -a: a;
}

struct PO{
    int co[MAXC];
    friend bool operator < (const PO &a, const PO &b){
        for(int i = 0; i < MAXC; ++i)
            if(a.co[i] != b.co[i])
                return a.co[i] < b.co[i];
       return false;
    }
    friend bool operator == (const PO &a, const PO &b){
        for(int i = 0; i < MAXC; ++i)
            if(a.co[i] != b.co[i])
                return false;
       return true;
    }
} po[MAXN];

int D;

bool cmp(const PO &a, const PO &b){
    return a.co[D] < b.co[D];
}

inline int dis(const PO &a, const PO &b){
    int ret = 0;
    for(int i = 0; i < MAXC; ++i) ret += ABS(a.co[i]-b.co[i]);
    return ret;
}

inline int dis2(const PO &a, const PO &b1, const PO &b2){
    int ret = 0;
    for(int i = 0; i < MAXC; ++i){
        if(a.co[i] < b1.co[i]) ret += b1.co[i]-a.co[i];
        if(a.co[i] > b2.co[i]) ret += a.co[i]-b2.co[i];
    }
    return ret;
}

inline int tra(int id){
    return id^1;
}

struct NO{
    PO ke, b1, b2;
    NO *ch[2];
    void up(NO *p){
        for(int i = 0; i < MAXC; ++i) {
            checkmin(b1.co[i], p->b1.co[i]);
            checkmax(b2.co[i], p->b2.co[i]);
        }
    }
};

struct PNO{
    int d;
    NO *p;
    PNO(){}
    PNO(int d_, NO *p_): d(d_), p(p_){}
};

struct CMP{
    bool operator()(const PNO &a, const PNO &b){
        return a.d > b.d;
    }
};

struct KDT{
    NO pool[MAXN*2], *rt, *re;
    PO K;
    int mdis;
    void init(){
        re = pool;
    }
    void build(NO *&p, int l, int r, int f){
        if(l > r){
            p = 0;
            return;
        }
        int m = (l+r) >> 1;
        D = f;
        nth_element(po+l, po+m, po+r+1, cmp);
        p = re++;
        p->ch[0] = p->ch[1];
        p->ke = p->b1 = p->b2 = po[m];
        build(p->ch[0], l, m-1, tra(f));
        build(p->ch[1], m+1, r, tra(f));
        if(p->ch[0]) p->up(p->ch[0]);
        if(p->ch[1]) p->up(p->ch[1]);
    }
    void add(NO *&p, const PO &k, int f){
        if(!p){
            p = re++;
            p->ke = p->b1 = p->b2 = k;
            p->ch[0] = p->ch[1] = 0;
            return;
        }
        if(p->ke == k) return;
        if(k.co[f] < p->ke.co[f]){
            add(p->ch[0], k, tra(f));
            p->up(p->ch[0]);
        }
        else{
            add(p->ch[1], k, tra(f));
            p->up(p->ch[1]);
        }
    }
    int query(const PO &k){
        K = k;
        mdis = INF;
        dfs(rt);
        return mdis;
    }
    void dfs(NO *p){
        int d = dis(p->ke, K);
        checkmin(mdis, d);
        int ld = p->ch[0]? dis2(K, p->ch[0]->b1, p->ch[0]->b2): INF;
        int rd = p->ch[1]? dis2(K, p->ch[1]->b1, p->ch[1]->b2): INF;
        if(ld < rd){
            if(p->ch[0]) dfs(p->ch[0]);
            if(rd < mdis) dfs(p->ch[1]);
        }else{
            if(p->ch[1]) dfs(p->ch[1]);
            if(ld < mdis) dfs(p->ch[0]);
        }
    }
/*
    int query(const PO &k){
        K = k;
        mdis = INF;
        priority_queue<PNO, vector<PNO>, CMP> que;
        dfs(rt, que);
        while(!que.empty() && mdis > que.top().d){
            PNO t = que.top();
            que.pop();
            int d = dis(t.p->ke, K);
            checkmin(mdis, d);
            int ld = t.p->ch[0]? dis2(K, t.p->ch[0]->b1, t.p->ch[0]->b2): INF;
            int rd = t.p->ch[1]? dis2(K, t.p->ch[1]->b1, t.p->ch[1]->b2): INF;
            if(ld < mdis) que.push(PNO(ld, t.p->ch[0]));
            if(rd < mdis) que.push(PNO(rd, t.p->ch[1]));
        }
        return mdis;
    }
    void dfs(NO *p,  priority_queue<PNO, vector<PNO>, CMP> &que){
        int d = dis(p->ke, K);
        checkmin(mdis, d);
        int ld = p->ch[0]? dis2(K, p->ch[0]->b1, p->ch[0]->b2): INF;
        int rd = p->ch[1]? dis2(K, p->ch[1]->b1, p->ch[1]->b2): INF;
        if(ld < rd){
            if(p->ch[0]) dfs(p->ch[0], que);
            if(rd < mdis) que.push(PNO(rd, p->ch[1]));
        }else{
            if(p->ch[1]) dfs(p->ch[1], que);
            if(ld < mdis) que.push(PNO(ld, p->ch[0]));
        }
    }*/
}kdt;

int main(){
    int n, m, t;
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; ++i)
        for(int j = 0; j < MAXC; ++j)
            scanf("%d", po[i].co+j);
    sort(po, po+n);
    int tn = unique(po, po+n)-po;
    kdt.init();
    kdt.build(kdt.rt, 0, tn-1, F);
    PO ke;
    for(int i = 0; i < m; ++i){
        scanf("%d%d%d", &t, ke.co, ke.co+1);
        if(t == 1)
            kdt.add(kdt.rt, ke, F);
        else
            printf("%d\n", kdt.query(ke));
    }
    return 0;
}
</span>


第K大，加了bbf反而效率更低

http://tsinsen.com/ViewGProblem.page?gpid=A1302


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <utility>
#include <cstring>
#include <map>
#include <climits>
#include <queue>
using namespace std;

typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned UI;

const int MAXN(100010);
const int MAXK(100010);
const int MAXL(10);
const int MAXC(2);
const int INF(INT_MAX-1);
const int F(0);
const LL LIM(1LL << 62);

template<typename T>
inline bool checkmax(T &a, const T &b){
    return b > a? ((a = b), true): false;
}

template<typename T>
inline bool checkmin(T &a, const T &b){
    return b < a? ((a = b), true): false;
}

template<typename T>
inline T ABS(T a){
    return a < 0? -a: a;
}

struct PO{
    int co[MAXC], id;
    friend bool operator < (const PO &a, const PO &b){
        for(int i = 0; i < MAXC; ++i)
            if(a.co[i] != b.co[i])
                return a.co[i] < b.co[i];
       return false;
    }
    friend bool operator == (const PO &a, const PO &b){
        for(int i = 0; i < MAXC; ++i)
            if(a.co[i] != b.co[i])
                return false;
       return true;
    }
} po[MAXN], tpo[MAXN];

int D;

bool cmp(const PO &a, const PO &b){
    return a.co[D] < b.co[D];
}

inline LL dis(const PO &a, const PO &b){
    LL ret = 0;
    for(int i = 0; i < MAXC; ++i)
        ret += (LL)ABS(a.co[i]-b.co[i])*ABS(a.co[i]-b.co[i]);
    return ret;
}

inline int dis2(const PO &a, const PO &b1, const PO &b2){
    int ret = 0;
    for(int i = 0; i < MAXC; ++i){
        if(a.co[i] < b1.co[i]) ret += b1.co[i]-a.co[i];
        if(a.co[i] > b2.co[i]) ret += a.co[i]-b2.co[i];
    }
    return ret;
}

inline LL dis3(const PO &a, const PO &b1, const PO &b2){
    LL ret = 0;
    for(int i = 0; i < MAXC; ++i){
        LL t = max(ABS(a.co[i]-b1.co[i]), ABS(a.co[i]-b2.co[i]));
        ret += t*t;
    }
    return ret;
}

inline int tra(int id){
    return id^1;
}

struct NO{
    PO ke, b1, b2;
    NO *ch[2];
    void up(NO *p){
        for(int i = 0; i < MAXC; ++i) {
            checkmin(b1.co[i], p->b1.co[i]);
            checkmax(b2.co[i], p->b2.co[i]);
        }
    }
};

struct PNO{
    LL d;
    int id;
    PNO(){}
    PNO(LL d_, int i_): d(d_), id(i_){}
    friend bool operator >(const PNO &a, const PNO &b){
        return a.d == b.d? a.id < b.id: a.d > b.d;
    }
};

struct CMP{
    bool operator()(const PNO &a, const PNO &b){
        return a.d == b.d? a.id < b.id: a.d > b.d;
    }
};

struct PNO2{
    LL d;
    NO *p;
    PNO2(){}
    PNO2(LL d_, NO *p_): d(d_), p(p_){}
    friend bool operator <(const PNO2 &a, const PNO2 &b){
        return a.d < b.d;
    }
};

struct KDT{
    NO pool[MAXN], *rt, *re;
    PO K;
    int C;
    int mdis;
    void init(){
        re = pool;
    }
    void build(NO *&p, int l, int r, int f){
        if(l > r){
            p = 0;
            return;
        }
        int m = (l+r) >> 1;
        D = f;
        nth_element(po+l, po+m, po+r+1, cmp);
        p = re++;
        p->ch[0] = p->ch[1];
        p->ke = p->b1 = p->b2 = po[m];
        build(p->ch[0], l, m-1, tra(f));
        build(p->ch[1], m+1, r, tra(f));
        if(p->ch[0]) p->up(p->ch[0]);
        if(p->ch[1]) p->up(p->ch[1]);
    }
    void add(NO *&p, const PO &k, int f){
        if(!p){
            p = re++;
            p->ke = p->b1 = p->b2 = k;
            p->ch[0] = p->ch[1] = 0;
            return;
        }
        if(p->ke == k) return;
        if(k.co[f] < p->ke.co[f]){
            add(p->ch[0], k, tra(f));
            p->up(p->ch[0]);
        }
        else{
            add(p->ch[1], k, tra(f));
            p->up(p->ch[1]);
        }
    }
    int query(const PO &k, int c){
        K = k;
        C = c;
        priority_queue<PNO, vector<PNO>, CMP> que;
        priority_queue<PNO2, vector<PNO2> > que2;
        dfs(rt, que, que2);
        while(!que2.empty() && (que.size() < C || que2.top().d >= que.top().d)){
            PNO2 cur = que2.top();
            que2.pop();
            PNO t(dis(cur.p->ke, K), cur.p->ke.id);
            if(que.size() < C)
                que.push(t);
            else
                if(t > que.top()){
                    que.pop();
                    que.push(t);
                }
            LL ld = cur.p->ch[0]? dis3(K, cur.p->ch[0]->b1, cur.p->ch[0]->b2): -LIM;
            LL rd = cur.p->ch[1]? dis3(K, cur.p->ch[1]->b1, cur.p->ch[1]->b2): -LIM;
            if(cur.p->ch[0] && (que.size() < C || ld >= que.top().d)) que2.push(PNO2(ld, cur.p->ch[0]));
            if(cur.p->ch[1] && (que.size() < C || rd >= que.top().d)) que2.push(PNO2(rd, cur.p->ch[1]));
        }
        return que.top().id;
    }
    void dfs(NO *p,  priority_queue<PNO, vector<PNO>, CMP> &que, priority_queue<PNO2, vector<PNO2> > &que2){
        PNO t(dis(p->ke, K), p->ke.id);
        if(que.size() < C)
            que.push(t);
        else
            if(t > que.top()){
                que.pop();
                que.push(t);
            }
        LL ld = p->ch[0]? dis3(K, p->ch[0]->b1, p->ch[0]->b2): -LIM;
        LL rd = p->ch[1]? dis3(K, p->ch[1]->b1, p->ch[1]->b2): -LIM;
        if(ld > rd){
            if(p->ch[0]) dfs(p->ch[0], que, que2);
            if(p->ch[1] && (que.size() < C || rd >= que.top().d)) que2.push(PNO2(rd, p->ch[1]));
        }else{
            if(p->ch[1]) dfs(p->ch[1], que, que2);
            if(p->ch[0] && (que.size() < C || ld >= que.top().d)) que2.push(PNO2(ld, p->ch[0]));
        }
    }
}kdt;

int main(){
    int n, m, c;
    scanf("%d", &n);
    for(int i = 0; i < n; ++i){
        scanf("%d%d", po[i].co, po[i].co+1);
        po[i].id = i;
        tpo[i] = po[i];
    }
    kdt.init();
    kdt.build(kdt.rt, 0, n-1, F);
    scanf("%d", &m);
    PO t;
    for(int i = 0; i < m; ++i){
        scanf("%d%d%d", t.co, t.co+1, &c);
        printf("%d\n", kdt.query(t, c)+1);
    }
    return 0;
}


B树与K-D Tree：高维空间数据索引对比
AI 算法实战派
06-09 852
本文旨在帮助读者理解B树和K-D Tree这两种重要数据结构的核心原理、实现方式以及在高维数据索引中的适用场景。我们将重点关注它们在处理不同维度数据时的性能特点和取舍考量。核心概念与联系：解释B树和K-D Tree的基本原理算法原理与实现：展示两种数据结构的Python实现性能对比分析：比较两种结构在不同场景下的表现实际应用案例：展示在数据库和机器学习中的应用未来发展趋势：探讨高维数据索引的新方向B树：一种自平衡的树数据结构，保持数据有序并允许高效搜索、顺序访问、插入和删除。
面试算法压轴题（K-D Tree的应用）详细解析
米莱虾
09-05 821
目录 给出一个应用场景： 思路过程及知识点引入： 何为 K-D Tree K-D Tree 有怎样的特征优势，能解决怎样的问题 重难点：如何利用 K-D Tree 解决上面的问题 K-D Tree 这种数据结构为什么叫做 K-D Tree 如何建树 建树之后如何查询 K-D Tree 的一个 code模板： 给出一个应用场景： 在一个二维平面中，有一些补给点存在，所有补给点的位置不会改变，玩家可操作角色在平面内随意移动，求在任何时刻距角色最近的补给点。 其实这个问题就是：给定..
ElasticSearch搜索进阶之路之高维数据的BKD树结构
weixin_48594156的博客
09-09 801
BKD树，全称为b-树形kd树（bushy kd-trees），是一种用于高维数据搜索的数据结构。它是基于kd树（k-dimensional tree）的改进版本。
Lucene 7.5.0 Bkd Tree
q364367207的专栏
04-22 2548
Bkd-Tree作为一种基于K-D-B-tree的索引结构，用来对多维度的点数据(multi-dimensional point data)集进行索引。Bkd-Tree跟K-D-B-tree的理论部分在本篇文章中不详细介绍，对应的两篇论文在附件中，感兴趣的朋友可以自行下载阅读。本篇文章中主要介绍Bkd-Tree在Lucene中的实现，即生成树的过程。 看这里：http://www.amazing...
BKD tree构造过程
chuanyangwang的专栏
10-05 610
1. 将所有的点数据，写在内存中。并统计其总数 2. 根据其总数和每个叶子结点最多点数据的数量， 得出叶子结点的数量 long countPerLeaf = pointCount = values.size(); long innerNodeCount = 1; while (countPerLeaf > maxPointsInLeafNode) { countPerLeaf = (countPerLeaf+1)/2; innerNodeCoun
b-k-d树 原理 图文解析
stevewong的专栏
06-11 3260
背景 前文介绍了 k-d树 和 k-d-b树 今天再来这个b-k-d树已经几乎没啥可以参考的资料了 只能硬啃两篇文章了 一个是：medium 一个是发明者的论文 挺好的，人还是要耐着性子读一些难啃的东西 开始介绍 关键点 这个b-k-d树是基于k-d-b树再做的改进，整体的结构是个森林。。（多个k-d-b树） 前文介绍，k-d-b树在做静态查询的时候效果特别好，但是动态插入就不好了。 为了解决这种问题，作者研究了这种炸天的算法，用一个森林来做。。 仔仔细细地看插入算法： 在内存中有一个完全二叉树作为bu
BKD树介绍、区别与联系
大数据，大模型，服务器，技术、架构，方案
10-11 986
BKD树（全称 bushy kd-trees）是一种用于高维数据搜索的数据结构。它结合了K-D树和B树的特点，旨在提高多维空间数据的索引和查询效率。BKD树是一种高效且灵活的数据结构，特别适用于处理高维空间数据。通过递归分割和动态调整，BKD树能够实现高效的查询和空间管理，广泛应用于各种需要多维数据索引的场景。
简单剖析B树（B-Tree）与Ｂ+树
07-19 159
https://blog.youkuaiyun.com/z_ryan/article/details/79685072 ...
Tree-of-Traversals: A Zero-Shot Reasoning Algorithm for Augmenting Black-box Language Models with Kn
weixin_43961909的博客
09-24 1331
知识图谱 (KG) 通过提供可靠、结构化、领域特定和最新的外部知识来补充大型语言模型 (LLM)。然而，KG 和 LLM 通常是分开开发的，必须在训练后集成。我们引入了 Tree-of-Traversals，这是一种新颖的零样本推理算法，可以使用一个或多个 KG 来增强黑盒 LLM。该算法为 LLM 配备了与 KG 交互的操作，并使 LLM 能够对可能的想法和操作执行树搜索，以找到高置信度的推理路径。我们在两个流行的基准数据集上进行了评估。
Zero-Shot Multi-Hop Question Answering via Monte-Carlo Tree Search with Large Language Models
weixin_43961909的博客
03-09 865
大型语言模型(LLM)的最新进展极大地影响了多跳问答(MHQA)领域，在该领域中，系统需要从不同的文本片段中聚集信息并推断答案。然而，LLM的自回归性质固有地提出了一个挑战，因为如果在中间推理步骤中出现错误，错误可能会累积。介绍了零炮多跳问题回答的蒙特卡罗树搜索(MZQA)，这是一个基于蒙特卡罗树搜索(MCTS)的框架，用于识别MHQA任务中的最优推理路径，减少顺序推理过程中的错误传播。
基于LSM-Tree 的分布式组件化 KV 存储系统 | DB·洞见回顾
weixin_43872058的博客
05-13 891
随着云服务基础架构以及微服务技术的日益成熟，很多大型系统能够分解为根据应用 workload 需求的多个子系统，再通过网络交互组装在一起协同工作。 Nova-LSM，一个将基于LSM-Tree的分布式KV 存储系统分解为使用RDMA进行通信的组件的工作。这些组件将存储与处理分开，使处理组件能够共享存储带宽和空间。处理组件将文件块 (SSTable) 分散到任意数量的存储组件中，并通过一定机制平衡它们之间的负载，在运行时动态构建范围以并行化压缩并提高性能。Nova-LSM 具有很好的可伸缩性，在一些场景下性能
K-D tree 数据结构
热门推荐
蛤蛤~
08-11 2万+
首先来一个问题：     给定平面上一个点集 E ，还有一个定点 V ，怎么在一群点中找出一个点 U，使得 V 与 U 的距离最近（欧几里得距离）？ 当然，我们能够想到一种做法：枚举 E 中所有的点，找出它们中距离V 最近的点 U。 但是，假设现在有两个点集 E1 与 E2 ，对于 E2 中每一个点 Vi ，找出一个在E1 中的一个点 Ui，使得 Vi 到 Ui 的距离最短，这怎么做？还是枚
KD Tree学习笔记
Lolierl的博客
11-28 439
KD Tree学习笔记 KD Tree 是一种用于多维数点的数据结构（一般是二维）。它并不特别复杂，本质其实很暴力，和替罪羊树与线段树都比较类似。 大致思路：每次把点分为尽可能平衡的两半，然后通过类似线段树的方式拆分查询区间，以此控制复杂度。 算法流程 构建： 如果已经给定了一些元素（k维），构建kdtree采用以下的方式： 首先，将当前区间按照第d维的中间数左右分段。d每分一层便换到下一个维度，...
写给 Baby 的 Kd-tree 实现原理
Robotics_Notes
08-10 219
这里主要涉及 2 维的Kd 树的构建、最近邻搜索 (Nearest neighbor search, NN search)、K 最近邻搜索 (K-nearest neighbor search, KNN search).K 最近邻搜索与最近邻搜索的思想和实现都差不多, 两个实现之间可以继承, 只是要在计算过程中维护一个前 K 个最近邻的数组.Kd 树是一种树形的描述空间点云的数据结构和算法.关键就两点最小距离的更新、分支界定的剪枝.完整 demo 程序见本文绑定资源.
K-D Tree（K维空间数据结构）
既然弱小，就只顾变强就是了
03-23 2470
K-D Tree是K临近算法中的一种 k-d 是 k-dimensional 的缩写，也就是k维树，换句话说就是说这个树是维护一个k维元素的树，这个树上的节点有k个分量。一个k维的二叉搜索树就是k-d tree了。 先了解一下K-D Tree的概念 例子（网图） K == 3的K-D Tree模型 首先来看下树的组织原则。将每一个元组按0排序（第一项序号为0，第二项序号为...
K-D树
ACdreamer
03-27 1万+
K-D树，即K-Dimensional Tree，是一种高维索引树型数据结构。常用于大规模高维数据空间的最邻近或者K邻 近查找，例如图像检索中高维图像特征向量的K邻近匹配，对KNN算法的优化等。   Contents      1. K-D树的基本原理    2. K-D树的改进（BBF算法）    3. K-D树的C++实现    4. K-D树的开源框架介绍     1.
Lucene 查询原理
weixin_33755847的博客
04-16 335
前言 Lucene 是一个基于 Java 的全文信息检索工具包，目前主流的搜索系统Elasticsearch和solr都是基于lucene的索引和搜索能力进行。想要理解搜索系统的实现原理，就需要深入lucene这一层，看看lucene是如何存储需要检索的数据，以及如何完成高效的数据检索。 在数据库中因为有索引的存在，也可以支持很多高效的查询操作。不过对比...
校门外有很多树，学校决定在某个时刻在某一段种上一种树，保证任一时刻不会出现两段相同种类的树，现有两种操作： K = 1 K=1，读入 l , r l,r 表示在 l l 到 r r 之间种上一种树，每次操作种的树的种类都不同； K = 2 K=2，读入 l , r l,r 表示询问 l l 到 r r 之间有多少种树。 注意：每个位置都可以重复种树。 #include<iostream> using namespace std; int n,q; long long tree[1000006],tree2[1000006]; long long lowbit(long long x) { return (x & (-x)); } void update(int x,long long y) { if(x == 0) return; while(x <= n) { tree[x] += y; x += lowbit(x); } } void update2(int x,long long y) { if(x == 0) return; while(x <= n) { tree2[x] += y; x += lowbit(x); } } long long get(int x) { if(x == 0) return 0; long long ans = 0; while(x > 0) { ans += tree[x]; x -= lowbit(x); } return ans; } long long get2(int x) { if(x == 0) return 0; long long ans = 0; while(x > 0) { ans += tree2[x]; x -= lowbit(x); } return ans; } int main() { ios::sync_with_stdio(0); cin.tie(0),cout.tie(0); cin >> n >> q; while(q--) { int mod,l,r; cin >> mod >> l >> r; if(mod == 1) { update(l,1); update(r + 1,-1); update2(l,l - 1); update2(r + 1,-r); } else { cout << r * get(r) - get2(r) - (l - 1) * get(l - 1) + get2(l - 1) - 1 << '\n'; } } }
最新发布
07-26
我们考虑：在标准的方法中，我们使用两个树状数组来支持区间加和区间求和，其中一个树状数组维护tree1（差分数组d），另一个树状数组维护tree2（差分数组d*i），那么区间和可以表示为： sum_{i=1}^{x} a[i] = (x+1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值