LCA 三种姿势(倍增,Tarjan+并查集,树链剖分)

本文详细介绍了三种求解树上最近公共祖先(LCA)的算法:1) 倍增算法,利用二进制拆分实现O((n+m)logn)的时间复杂度;2) Tarjan离线算法,通过路径压缩达到线性时间复杂度O(n+m);3) 树链剖分算法,将树剖分为重链,查询时复杂度为O(logn)。每种算法都结合了深度优先搜索(DFS)和辅助数据结构,如祖先数组和并查集。这些算法在解决树结构问题时具有高效性和实用性。

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

LCA 三种姿势(倍增,Tarjan+并查集,树链剖分)

jjX7gs.png

1.倍增求 LCA O ( ( n + m ) l o g n ) O((n+m)logn) O((n+m)logn)

  1. d e p [ u ] dep[u] dep[u] 表示 u u u 节点的深度。
  2. f a [ u ] [ i ] fa[u][i] fa[u][i] 表示从 u u u 节点向上跳跃 2 i 2^i 2i 层的祖先节点。

Q1:为什么要定义成 2 i 2^i 2i , 3 i 3^i 3i 不是更快?

主要是因为需要用到二进制拆分,所有的数可以表示成某些 2 的次幂的和。

vector<int>e[N];
int dep[N],fa[N][20];

打表:倍增递推,从小到大枚举
void dfs(int u,int father){
    dep[u] = dep[father] + 1;
    fa[u][0] = father;
    for(int i=1;i<=19;i++){
        fa[u][i] = fa[fa[u][i-1]][i-1];
    }
    for(int v:e[u]){
        if(v!=father)dfs(v,u);
    }
}
int lca(int u,int v){
    if(dep[u] < dep[v])swap(u,v);
    // 2进制拆分,从大到下跳跃
    for(int i=19;i>=0;i--){
        // u不能跳到v上边去
        if(dep[fa[u][i]]>=dep[v])
            u = fa[u][i];
    }
    // v恰好是u的lca
    if(u == v)return v;
    // u,v一起跳
    for(int i=19;i>=0;i--){
        // 不能越界,一块跳到lca的下一个节点。
        if(fa[u][i] != fa[v][i]){
            u = fa[u][i];
            v = fa[v][i];
        }
    }
    return fa[u][0];
}

y总的板子:
void bfs(int root)
{
    memset(depth, 0x3f, sizeof depth);
    depth[0] = 0, depth[root] = 1;
    int hh = 0, tt = 0;
    q[0] = root;
    while (hh <= tt)
    {
        int t = q[hh ++ ];
        for (int i = h[t]; ~i; i = ne[i])
        {
            int j = e[i];
            if (depth[j] > depth[t] + 1)
            {
                depth[j] = depth[t] + 1;
                q[ ++ tt] = j;
                fa[j][0] = t;
                for (int k = 1; k <= 15; k ++ )
                    fa[j][k] = fa[fa[j][k - 1]][k - 1];
            }
        }
    }
}

int lca(int a, int b)
{
    if (depth[a] < depth[b]) swap(a, b);
    for (int k = 15; k >= 0; k -- )
        if (depth[fa[a][k]] >= depth[b])
            a = fa[a][k];
    if (a == b) return a;
    for (int k = 15; k >= 0; k -- )
        if (fa[a][k] != fa[b][k])
        {
            a = fa[a][k];
            b = fa[b][k];
        }
    return fa[a][0];
}

感觉 dfs 更短一些。

2.Tarjan离线求 LCA O ( ( n + m ) ) 线性! O((n+m))线性! O((n+m))线性!

  1. f a [ u ] fa[u] fa[u] 表示 u u u 节点的父亲节点。
  2. v i s [ u ] vis[u] vis[u] 标记数组,防止向回深搜
  3. 非常有特点的 vector<pair<int,int>>query[N] 表示 query[u]={v,i} 表示第 i i i 次询问 ( u , v ) (u,v) (u,v) L C A LCA LCA 是什么。
  4. 每个查询必须正反建立一次!,不然结果不对
query[u] = {v,i};
query[v] = {u,i};
vector<int>e[N];
vector<pair<int,int>>query[N];
int fa[N],vis[N],ans[M];

int find(int u){ // 带路径压缩
    return fa[u] == u ? fa[u] : fa[u] = find(fa[u]);
}
void tarjan(int u){
	vis[u] = 1;
    for(auto j:e[u]){ // O(n)
        if(!vis[j]){
            tarjan(j);
            fa[j] = u; // 返回u时,j指向他的父亲u
        }
    }
    // 离开u时,枚举以u为起点的LCA询问。 O(m)
    for(auto q:query[u]){
        int v = q.first;
        int i = q.second;
        if(vis[v]){
            ans[i] = find(v); 
		}
    }
}

3.树链剖分求 LCA O ( ( n + m ( 查询次数 ) l o g n ) ) O((n+m(查询次数)logn)) O((n+m(查询次数)logn))

前置知识:

重儿子 :父节点的所有儿子中子树节点最多的节点 (如果有多个重儿子,任选一个)。
轻儿子:父节点中除重儿子以外的儿子,(也是轻儿子)。
重边:父节点和重儿子连成的边。
轻边:父节点和轻儿子连成的边。
重链: 由多条重边连接而成的路径,独立的节点自身也是重链。

  1. 整棵树会被剖分成若干条重链。
  2. 轻儿子一定是每条重链的顶点。
  3. 任意一条路径被切分成不超过 O ( l o g n ) O(logn ) O(logn) 条链

f a [ u ] fa[u] fa[u] u u u 的父节点。
d e p [ u ] dep[u] dep[u] u u u 的深度
s o n [ u ] son[u] son[u] u u u 的重儿子。
s z [ u ] sz[u] sz[u] u u u 为根子树节点数。
t o p [ u ] top[u] top[u] u u u 所在重链的顶点。


流程:

  1. 第一遍 dfs,预处理 f a [   ] , d e p [   ] , s o n [   ] , s z [   ] fa[\ ],dep[\ ],son[\ ],sz[\ ] fa[ ],dep[ ],son[ ],sz[ ]
  2. 第二遍 dfs,预处理 t o p [   ] top[\ ] top[ ]
  3. L C A LCA LCA

轻儿子的链头一定是他自身,叶节点没有重儿子。

jjrsqf.png

vector<int>e[N];
int fa[N],dep[N],son[N],sz[N];
int top[N];

void dfs1(int u,int father){ // O(n)
    fa[u] = father,dep[u] = dep[father]+1,sz[u]=1;
    for(int j:e[u]){
        if(j==u)continue;
        dfs1(j,u);
        // 回溯之后更新子树节点数目和重儿子
        sz[u] += sz[v];
        if(sz[son[u]] < sz[v])son[u] = v;
    }
}

void dfs2(int u,int t){ // 处理top数组,t记录重链头节点  O(n)
    top[u] = t;
    if(!son[u]) return ; // 遍历到了叶节点
    dfs2(son[u],t); // 先欧重儿子
    for(int j:e[u]){
        if(j == fa[u] || j == son[u])continue;// 特判重复边和指向重儿子的边
        dfs2(j,j); // 搜轻儿子
    }
}
int lca(int u,int v){ // O(log n )
    while(top[u]!=top[v]){
        if(dep[top[u]] < dep[top[v]])swap(u,v);
        u = fa[top[u]];
    }
    // u,v在同一条重链上,谁的深度浅返回谁。
    return dep[u] < dep[v] ? u : v;
}

再次回顾:
jjX7gs.png

<think>好的,我现在需要帮助用户了解“树上差分、树链剖分、树上分治、树上DUS”这几个概念。首先,用户之前已经询问过“树上统计”,现在继续深入询问更具体的算法和技术,说明他们可能正在学习算法竞赛或高级数据结构,特别是树相关的问题。 首先,我需要确定每个术语的正确含义和常见中文翻译。用户提到的“树上DUS”可能是指Disjoint Set Union(并查集)在树上的应用,但“DUS”可能是拼写错误,正确缩写应为DSU(Disjoint Set Union),也就是并查集。因此,我需要确认这一点,并在回答时做出说明。 接下来,每个术语的解释需要准确且易于理解。用户可能希望了解这些技术的基本思想、应用场景以及可能的代码示例。考虑到用户之前的问题中有代码示例,可能期望这里也有类似的示例,但需要根据复杂度决定是否提供。 对于“树上差分”,需要解释其与数组差分的区别,以及在树结构中的应用,比如处理路径更新和子树查询。常见的例子是离线处理多次路径修改后的节点值统计。 树链剖分(重链剖分)主要用于将树分割成链,以便高效处理路径查询。需要解释其原理、步骤(如重儿子选择、DFS序划分)以及应用,比如结合线段树处理路径上的操作。 树上分治可能指的是点分治或边分治,用于处理树上的路径问题,比如统计满足某些条件的路径数量。点分治通过选择重心分解树,降低问题复杂度,需要说明其步骤和优势,比如处理O(n log n)复杂度的问题。 “DUS”如果是DSU的话,通常用于处理连通性问题,但在树上的应用可能涉及离线查询,比如Tarjan算法LCA。需要说明如何利用并查集处理树上的离线查询,如连接节点并处理查询。 在组织回答时,需要结构清晰,每个部分分点说明,包括基本思想、应用场景、实现步骤和示例。同时,要注意术语的正确性,例如确认“DUS”的正确性,并在回答中做出提示,避免误解。 用户可能的深层需求是准备算法竞赛,或者解决实际问题中的树结构相关问题,因此需要强调每个技术的适用场景和优势,帮助他们选择合适的方法。此外,可能需要提供参考资料或例题链接,如LeetCode或OJ题目,方便用户进一步练习。 需要检查每个解释是否准确,比如树链剖分是否确实用于路径查询,点分治是否用于路径统计等。同时,确保语言简洁,避免过于技术化的术语,必要时用比喻或示例帮助理解。 最后,确保回答覆盖用户提到的所有四个术语,没有遗漏,并对可能的拼写错误进行纠正说明,以提升回答的准确性和帮助性。</think>以下是关于 **树上差分、树链剖分、树上分治、树上DUS** 的详细介绍,结合它们的核心思想和应用场景: --- ## **1. 树上差分** ### **基本思想** - 树上差分是 **处理树上的区间/路径修改** 的高效方法,类似于数组的差分思想。通过标记路径的起点和终点,最后通过一次遍历(如DFS)累加标记,得到最终结果。 - **典型场景**:多次对树上的某条路径进行增减操作(如边权或节点权值的修改),最后统一查询每个节点的最终值。 ### **实现步骤** 1. **路径标记**:对于路径 `u → v`,在差分数组中将 `u` 和 `v` 的权值增加,同时将它们的最近公共祖先(LCA)的权值减少两次(抵消多余贡献)。 2. **后序遍历累加**:通过DFS从叶子到根累加差分值,得到每个节点的最终值。 ### **示例问题** - **题目**:给一棵树,多次操作在路径 `u→v` 上所有节点权值 +k,最后查询每个节点的值。 - **代码片段**: ```python def tree_diff(u, v, lca, k, diff): diff[u] += k diff[v] += k diff[lca] -= k if parent[lca] exists: diff[parent[lca]] -= k ``` --- ## **2. 树链剖分(重链剖分)** ### **基本思想** - 将树分割为若干条 **重链**(Heavy Path),使得树上任意路径的查询/修改可转化为对 `O(log n)` 条链的操作,从而结合线段树等数据结构高效处理。 - **核心概念**: - **重儿子**:子树大小最大的子节点。 - **轻边**:连接非重儿子的边。 - **DFS序**:按遍历顺序将节点映射到连续区间,便于线段树维护。 ### **应用场景** - 路径查询:求路径上的最大值、和、或修改路径上的权值。 - 子树查询:子树权值统计。 ### **代码实现(简化步骤)** ```python def dfs(u, parent): size[u] = 1 for v in children[u]: if v != parent: dfs(v, u) size[u] += size[v] if size[v] > size[heavy[u]]: heavy[u] = v # 标记重儿子 def decompose(u, head): top[u] = head # 当前链的顶端 if heavy[u] exists: decompose(heavy[u], head) # 优先处理重儿子(形成重链) for v in light_children[u]: decompose(v, v) # 轻边开启新链 ``` --- ## **3. 树上分治(点分治/边分治)** ### **基本思想** - **点分治**:通过选择树的重心(删除后最大子树最小的节点)将树分解为多个子树,递归处理每个子树的路径问题,合并时统计跨重心的路径。 - **边分治**:类似点分治,但选择一条边分割树(较少用,因树可能需重构为二叉树)。 ### **应用场景** - 统计满足条件的路径数量(如路径长度 ≤ k)。 - 经典问题:树的重心分解后处理所有路径的组合。 ### **点分治步骤** 1. 找到当前树的重心,删除重心后分裂为多个子树。 2. 计算经过重心的所有路径贡献。 3. 递归处理每个子树。 ### **示例问题** - **题目**:求树上路径长度等于 k 的路径数(LeetCode [437. 路径总和 III](https://leetcode.cn/problems/path-sum-iii/) 的扩展)。 --- ## **4. 树上DUS(Disjoint Set Union,并查集)** ### **基本思想** - 在树上应用并查集(DSU),通常用于 **离线处理连通性问题** 或 **路径压缩查询**。例如: - **Tarjan离线LCA算法**:通过DFS和并查集,预处理所有查询的最近公共祖先。 - **动态连通性**:处理树的边删除或动态连接。 ### **实现示例(TarjanLCA)** ```python def tarjan(u): visited[u] = True for v in children[u]: tarjan(v) union(u, v) # 将子节点合并到当前节点 for query_v in queries[u]: if visited[query_v]: lca = find(query_v) # 通过并查集找到LCA ``` --- ## **对比与应用场景** | 方法 | 核心用途 | 时间复杂度 | 典型问题 | |--|----------------------------| | 树上差分 | 路径批量修改 + 单次查询 | O(n + m) | 多次路径修改后统计节点值 | | 树链剖分 | 路径/子树频繁查询或修改 | O(log n) 单次 | 路径最大值、和 | | 树上分治 | 统计所有满足条件的路径 | O(n log n) | 路径长度等于k的路径数 | | 树上DUS | 离线LCA、连通性问题 | O(n α(n)) | Tarjan算法LCA | -- 如果需要具体问题的代码实现或进一步解释,可以告诉我场景哦!
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值