适用于普通树或 n 元树的 LCA（稀疏矩阵 DP 方法）

本文介绍一种适用于普通树或 n 元树的 LCA（最近公共祖先）算法，该算法使用稀疏矩阵 DP（动态规划）方法，时间复杂度为 $O(n\log n)$，空间复杂度为 $O(n\log n)$。

问题

在一棵树上，给定两个节点 $u$ 和 $v$，LCA 指的是在树上 $u$ 和 $v$ 的最近公共祖先节点。需要在一颗 n 叉树（或普通二叉树）中，快速地求出任意两个节点之间的 LCA。

算法

该算法基于稀疏矩阵的 DP 方法，算法主要步骤如下：

1. 对树进行 DFS（深度优先搜索），计算出每个节点的深度（depth）和父节点（parent）。
2. 构建稀疏矩阵，矩阵的大小为 $n\times \log n$，其中 $n$ 表示节点数，$\log n$ 表示深度的上界。矩阵的第 $i$ 行表示深度为 $i$ 的节点，第 $j$ 列表示离 $i$ 最近的深度为 $i-2^j$ 的祖先节点。
3. 对矩阵进行初始化，矩阵的第 $i$ 行第 $j$ 列的值为第 $2^j$ 个祖先节点的编号。
4. 对两个节点 $u$ 和 $v$，先将深度较深的节点上移，直到两个节点深度相同。然后根据稀疏矩阵的信息，往上跳 $2^k$ 步，直到两个节点最近的公共祖先节点。其中 $k$ 可以从 $\log d$ 开始递减，其中 $d$ 表示两个节点之间的深度差。

以下是实现的代码片段：

# 节点结构体
class Node:
    def __init__(self, val):
        self.val = val
        self.parent = None
        self.depth = 0

# 初始化 DP 矩阵
def init_matrix(n, matrix):
    for i in range(n):
        matrix[i][0] = nodes[i].parent.val
    for j in range(1, MAX_LEVEL):
        for i in range(n):
            if matrix[i][j-1] != -1:
                matrix[i][j] = matrix[matrix[i][j-1]][j-1]

# 查找 LCA
def find_lca(u, v):
    if u.depth < v.depth:
        u, v = v, u
    k = MAX_LEVEL - 1
    while u.depth > v.depth:
        if u.depth - (1 << k) >= v.depth:
            u = u.parent_list[k]
        k -= 1
    if u == v:
        return u
    k = MAX_LEVEL - 1
    while k >= 0:
        if u.parent_list[k] != v.parent_list[k]:
            u = u.parent_list[k]
            v = v.parent_list[k]
        k -= 1
    return u.parent_list[0]


# 常量定义
MAX_LEVEL = 20  # 稀疏矩阵的最大深度
n = 7  # 节点数
matrix = [[-1] * MAX_LEVEL for _ in range(n)]  # DP 矩阵

# 构建数节点
root = Node(0)
nodes = [root]
for i in range(1, n):
    node = Node(i)
    parent = nodes[(i - 1) // 2]
    node.parent = parent
    parent_list = [parent]*(MAX_LEVEL)
    parent_list[0] = parent
    j = 1
    while parent_list[j-1] and j < MAX_LEVEL:
        parent_list[j] = parent_list[j-1].parent_list[j-1]
        j += 1
    node.parent_list = parent_list
    node.depth = parent.depth + 1
    nodes.append(node)

# 初始化 DP 矩阵
init_matrix(n, matrix)

# 查找 LCA
u = nodes[4]
v = nodes[6]
lca = find_lca(u, v)
print(lca.val)  # 输出：0

总结

该算法使用稀疏矩阵的 DP 方法，可以在 $O(n\log n)$ 的时间复杂度内求出任意两个节点间的 LCA。需要注意的是，算法的空间复杂度也为 $O(n\log n)$，因此对于大规模数据的情况需要考虑其他方法。