使用 LCA 查询以查找给定树中两个节点之间的最大和最小权重

在树的操作中，查询给定树中两个节点之间的最大和最小权重是一个常见的需求。而 LCA（最近公共祖先）算法是一种高效的实现方式。

什么是 LCA

LCA 是指最近公共祖先。在树中，给定两个节点，它们的 LCA 是指它们的共同祖先中离目标节点最近的一个。

LCA 算法可以通过预处理来实现，时间复杂度为 O(nlogn)，空间复杂度为 O(nlogn)。这种算法可以高效地查询给定树中两个节点之间的最大和最小权重。

如何实现 LCA

LCA 的实现主要是基于树的预处理。预处理过程中，我们可以使用动态规划，将每个节点的祖先和一些额外信息存储在一个预处理数组中。

当需要查询给定树中两个节点之间的最大和最小权重时，我们只需要从两个节点开始，向上遍历它们的祖先，直到找到它们的公共祖先。

LCA 实现示例

以下是 LCA 算法的示例代码：

class LCA:
    def __init__(self, graph, root):
        self.graph = graph
        self.root = root
        self.preprocess()

    def preprocess(self):
        self.P = {}
        self.D = {}
        stack = [(self.root, None, 0)]
        while stack:
            node, parent, depth = stack.pop()
            self.P[node] = parent
            self.D[node] = depth
            for neighbor in self.graph[node]:
                if neighbor != parent:
                    stack.append((neighbor, node, depth+1))

        for power in range(1, int(math.log2(len(self.graph)))+1):
            for node in self.graph:
                ancestor = self.P[node]
                if ancestor is None:
                    continue
                self.P[node][power] = self.P[ancestor][power-1]

    def query(self, u, v):
        if self.D[u] < self.D[v]:
            u, v = v, u

        for power in range(int(math.log2(self.D[u])),-1,-1):
            if self.P[u][power] is not None and self.D[self.P[u][power]] >= self.D[v]:
                u = self.P[u][power]

        if u == v:
            return u

        for power in range(int(math.log2(self.D[u])),-1,-1):
            if self.P[u][power] is not None and self.P[v][power] != self.P[u][power]:
                u, v = self.P[u][power], self.P[v][power]

        return self.P[u][0]

在上面的代码中，我们使用了一个名为 P 的多维数组来存储每个节点的祖先。同时我们还使用了一个名为 D 的字典，来存储每个节点的深度。

在 query 函数中，我们首先找到两个节点深度更深的那个节点。然后我们从更深的节点向上遍历找到公共祖先。