最近公共祖先LCA求解

最新推荐文章于 2024-08-08 14:03:06 发布

JieFeiLau

最新推荐文章于 2024-08-08 14:03:06 发布

阅读量220

点赞数

分类专栏：数据结构与算法

本文链接：https://blog.csdn.net/u014028063/article/details/84539846

版权

数据结构与算法专栏收录该内容

24 篇文章 3 订阅

订阅专栏

1. 树上倍增

对于求 LCA, 最朴素的方法是"让两个点一起往上爬, 直到相遇", "如果一开始不在同一深度, 先爬到同一深度". 树上倍增求 LCA 的方法同样基于这个道理, 只不过利用了倍增思想从而加速了"向上爬"的操作. 也就是说, 每次向上爬的高度不是 1, 而是 2 的幂.

我们用 f(i,j)f(i,j) 表示从节点 ii 向上爬 2j2j 的高度所到达的节点, 则 f(i,0)f(i,0) 就代表节点 ii 的父节点. 那么对于任意的 f(i,j),j>0f(i,j),j>0, 有

f(i,j)=f(f(i,j−1),j−1)f(i,j)=f(f(i,j−1),j−1).

当我们要求两点的 LCA 时, 先让它们到同一高度. 这个过程我们使用二进制拆分来加速. 比如当两点高度相差 55时, (5)10=(101)2(5)10=(101)2, 那么我们就让高度较小的那个节点先往上爬 22=422=4 步, 再往上 20=120=1 步. 此时两点即在同一高度.

如果爬到同一高度后两点相同, 显然这个点就是它们的 LCA, 直接返回即可.

如果两点不同, 就一起往上爬. 这是一个无限逼近的过程, 直到找到它们的 LCA 的子节点为止. 详见代码.

for (int i = 1; i <= n; ++i)
    lg[i] = lg[i - 1] + (1 << lg[i - 1] + 1 == i);

int lca(int x, int y) {
    if (dep[x] < dep[y])
        swap(x, y);
    while (dep[x] > dep[y])
    x = f[x][lg[dep[x] - dep[y]]];
    if (x == y)
        return x;
    for (int k = lg[dep[x]]; k >= 0; --k)
        if (f[x][k] != f[y][k])
            x = f[x][k], y = f[y][k];
    return f[x][0];
}

(上面的代码预先算出了 log2(n)log2(n) 的值, 从而简化了代码.)

class Node(object):
    def __init__(self, data):
        self.data = data
        self.lchild = None
        self.rchild = None

    def getLCA(self, root, node1, node2):
        if root is None:
            return None
        if root == node1 or root == node2:
            return root
        left = self.getLCA(root.lchild, node1, node2)
        right = self.getLCA(root.rchild, node1, node2)
        if left and right:
            return root
        elif left:
            return left
        elif right:
            return right
        else:
            return None

2. Tarjan 算法

Tarjan 算法建立在 DFS 的基础上.

假如我们正在遍历节点 x, 那么根据所有节点各自与 x 的 LCA 是谁, 我们可以将节点进行分类: x 与 x 的兄弟节点的 LCA 是 x 的父亲, x 与 x 的父亲的兄弟节点的 LCA 是 x 的父亲的父亲, x 与 x 的父亲的父亲的兄弟节点的 LCA 是 x 的父亲的父亲的父亲... 将这些类别各自归入不同的集合中, 如果我们能够维护好这些集合, 就能够很轻松地处理有关 x 节点的 LCA 的询问. 显然我们可以使用并查集来维护.

Tarjan 算法的大致步骤如下:

1. 遍历 x 节点的子节点. 对于 x 节点的每个子节点, 该子节点遍历结束之后, 将其整棵子树合并到 x, 并保证合并之后祖先为 x;

2. 将 x 标记为已遍历;

3. 处理有关 x 的询问. 对于询问 (x, y), 如果 y 节点已遍历, 则 x 与 y 的 LCA 就是 y 节点所在集合的祖先; 否则, 将其推迟到遍历 y 时再处理.

代码如下:

void tarjan(int u) {
    fa[u] = u;
    
    int i, v;
    for (i = 0; i < tree[u].size(); i++) {
        v = tree[u][i];
        tarjan(v);
        fa[findset(v)] = u;
    }
    
    vis[u] = true;
    
    for (i = 0; i < query[u].size(); i++) {
        if (vis[query[u][i]]) {
            cnt[findset(query[u][i])]++;
        }
    }
}

(对于保证合并之后集合祖先为 x 这一步骤, 网络上的代码大多使用了一个 ancestor 数组来记录集合的祖先是谁. 原因是如果使用并查集的带秩合并, 合并两个集合之后不好确定根节点到底是谁. 但是带秩合并在有路径压缩的情况下作用有限, 所以这里取消了带秩合并而直接使用 fa[findset(v)] = u 来保证集合的祖先为 u.)