树上倍增算法与LCA查询实现详解-代码聚汇网

树上倍增算法与LCA查询实现详解

艾伦秋

1. 树上倍增与LCA算法基础

最近在刷算法题时遇到一类高频考点——需要快速查询树结构中任意两节点的最近公共祖先(LCA)。这类问题在算法竞赛和实际工程中都很常见，比如社交网络的关系分析、文件系统的目录结构处理等场景。今天我就来分享一个经过实战检验的树上倍增+LCA实现模板。

树上倍增算法的核心思想是通过预处理每个节点的2^k级祖先，将LCA查询的时间复杂度从O(n)优化到O(logn)。这种"空间换时间"的思路在树结构处理中非常实用。我们先看个简单例子：假设要查询节点u和v的LCA，可以先将较深的节点u跳到与v同深度，然后两者一起向上跳，直到找到第一个公共祖先。

2. 算法实现细节解析

2.1 数据结构设计

首先需要定义树的存储结构。我推荐使用邻接表来存储树，对于n个节点的树，可以这样定义：

cpp复制const int MAXN = 1e5 + 5; // 最大节点数
vector<int> tree[MAXN];   // 邻接表存储树结构
int depth[MAXN];          // 每个节点的深度
int up[MAXN][20];         // up[i][j]表示i节点的2^j级祖先

这里up数组就是倍增算法的核心，第二维大小取20是因为2^20足够覆盖大多数场景(约100万节点)。

2.2 预处理阶段实现

预处理采用DFS遍历，同时记录每个节点的深度和倍增祖先：

cpp复制void dfs(int u, int parent) {
    up[u][0] = parent;  // 直接父节点
    for(int i = 1; i < 20; i++) {
        up[u][i] = up[up[u][i-1]][i-1]; // 倍增思想核心
    }
    
    for(int v : tree[u]) {
        if(v != parent) {
            depth[v] = depth[u] + 1;
            dfs(v, u);
        }
    }
}

这个预处理的时间复杂度是O(nlogn)，因为每个节点需要处理20个祖先信息。

2.3 LCA查询实现

查询两个节点u和v的LCA时，主要分为三个步骤：

将较深的节点跳到与另一个节点同深度
如果此时两节点相同，直接返回
否则同时向上跳跃，直到找到LCA

具体实现：

cpp复制int lca(int u, int v) {
    if(depth[u] < depth[v]) swap(u, v);
    
    // 将u跳到与v同深度
    for(int i = 19; i >= 0; i--) {
        if(depth[u] - (1 << i) >= depth[v]) {
            u = up[u][i];
        }
    }
    
    if(u == v) return u;
    
    // 同时向上跳跃
    for(int i = 19; i >= 0; i--) {
        if(up[u][i] != up[v][i]) {
            u = up[u][i];
            v = up[v][i];
        }
    }
    
    return up[u][0];
}

3. 算法优化与性能分析

3.1 时间复杂度优化

预处理阶段：O(nlogn)
每次查询：O(logn)

相比暴力解法每次查询O(n)的时间复杂度，这在多次查询场景下优势明显。例如处理10万次查询时，暴力解法需要O(nq)=1e10次操作，而倍增法仅需O(nlogn + qlogn)≈2e6次操作。

3.2 空间复杂度分析

空间消耗主要来自up数组，大小为O(nlogn)。对于1e5个节点，约需要1e5×20×4B≈8MB内存，完全在合理范围内。

3.3 常数优化技巧

使用快速输入输出：对于大规模数据，建议使用scanf/printf或更快的IO方式
调整倍增层级：根据问题规模调整up数组第二维大小
循环展开：对于固定次数的循环(如20次)，可以手动展开优化

4. 典型应用场景与变种

4.1 基础应用场景

树中两点间最短路径：depth[u] + depth[v] - 2*depth[lca(u,v)]
判断节点是否在另一节点的子树中
树结构中的权限检查(如文件系统)

4.2 算法竞赛常见变种

带权树的最短路径：额外维护路径权值和
动态树问题：结合LCT(Link-Cut Tree)等数据结构
多次查询离线处理：Tarjan离线算法

4.3 实际工程应用

社交网络关系分析
代码版本控制系统中的合并基础查找
生物信息学中的物种最近共同祖先分析

5. 常见问题与调试技巧

5.1 常见错误排查

数组越界：确保MAXN足够大，特别是多测试用例时要重置
根节点设置：通常根节点的父节点设为自身或-1
深度初始化：根节点深度设为0或1要统一

5.2 调试技巧

小数据测试：构造简单树结构验证正确性
打印调试：输出预处理后的up数组检查
对拍测试：与暴力解法结果对比

5.3 性能优化建议

减少递归深度：对于极深树结构，改用BFS或迭代DFS
内存访问优化：调整数组访问顺序提高缓存命中率
指令级并行：适当使用SIMD指令加速

6. 完整模板代码实现

以下是经过多次验证的完整实现模板：

cpp复制#include <bits/stdc++.h>
using namespace std;

const int MAXN = 1e5 + 5;
const int LOG = 20;

vector<int> tree[MAXN];
int depth[MAXN];
int up[MAXN][LOG];

void dfs(int u, int parent) {
    up[u][0] = parent;
    for(int i = 1; i < LOG; i++) {
        up[u][i] = up[up[u][i-1]][i-1];
    }
    
    for(int v : tree[u]) {
        if(v != parent) {
            depth[v] = depth[u] + 1;
            dfs(v, u);
        }
    }
}

int lca(int u, int v) {
    if(depth[u] < depth[v]) swap(u, v);
    
    for(int i = LOG-1; i >= 0; i--) {
        if(depth[u] - (1 << i) >= depth[v]) {
            u = up[u][i];
        }
    }
    
    if(u == v) return u;
    
    for(int i = LOG-1; i >= 0; i--) {
        if(up[u][i] != up[v][i]) {
            u = up[u][i];
            v = up[v][i];
        }
    }
    
    return up[u][0];
}

int main() {
    // 示例用法
    int n; // 节点数
    cin >> n;
    
    // 建树
    for(int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        tree[u].push_back(v);
        tree[v].push_back(u);
    }
    
    // 预处理
    dfs(1, 1); // 假设1是根节点
    
    // 查询示例
    int q;
    cin >> q;
    while(q--) {
        int u, v;
        cin >> u >> v;
        cout << lca(u, v) << endl;
    }
    
    return 0;
}

7. 进阶应用与扩展思考

在实际使用中，我发现这个模板有几个可以优化的方向：

内存优化：对于固定树结构，可以改用更紧凑的存储方式
并行预处理：利用多线程加速大规模树的预处理
持久化支持：使数据结构可持久化，支持版本回溯

另一个实用的技巧是将LCA查询与其他树算法结合，比如与树链剖分结合处理路径查询，或者与莫队算法结合处理子树统计问题。