二叉树中最低的共同祖先组合3(使用RMQ)

在二叉树中找到两个节点的最低的共同祖先的问题是常见的问题。然而，在这里我们将介绍使用RMQ算法（区间最小值）的一个优化解决方案。

什么是RMQ算法？

RMQ算法是求解数列区间最值的一种算法。它可以使得查询任意区间的最值操作具有O(1)的时间复杂度，而且预处理的时间复杂度可以达到O(N)级别。

如何使用RMQ算法解决二叉树的最低共同祖先问题？

我们可以在二叉树的欧拉巡回序列中使用RMQ算法来解决二叉树的最低共同祖先问题。在二叉树的欧拉巡回序列中，每个节点出现两次，第一次表示进入该节点，第二次表示离开该节点。考虑到任意两个节点在欧拉巡回序列中的深度必然连续，我们可以用RMQ算法来查询这两个节点间深度最小的节点。

代码实现

我们可以使用ST算法来实现RMQ算法，它的时间复杂度为O(NlogN)。以下是使用ST算法解决二叉树的最低共同祖先问题的代码实现：

class ST:
    def __init__(self):
        self.st = None

    def build(self, arr):
        n = len(arr)
        k = int(math.log2(n))
        self.st = [[0 for j in range(k + 1)] for i in range(n)]

        for i in range(n):
            self.st[i][0] = i

        for j in range(1, k + 1):
            for i in range(n - (1 << j) + 1):
                if arr[self.st[i][j - 1]] < arr[self.st[i + (1 << (j - 1))][j - 1]]:
                    self.st[i][j] = self.st[i][j - 1]
                else:
                    self.st[i][j] = self.st[i + (1 << (j - 1))][j - 1]

    def query(self, arr, l, r):
        k = int(math.log2(r - l + 1))
        if arr[self.st[l][k]] < arr[self.st[r - (1 << k) + 1][k]]:
            return self.st[l][k]
        else:
            return self.st[r - (1 << k) + 1][k]

class LCA:
    def __init__(self, tree):
        self.D = []  # 节点深度数组
        self.R = []  # 节点欧拉巡回序列中第一次出现位置的数组
        self.T = tree
        self.st = ST()

    def dfs(self, u, p, d):
        self.D.append(d)
        self.R.append(len(self.D) - 1)

        for v in self.T[u]:
            if v == p:
                continue
            self.dfs(v, u, d + 1)
            self.D.append(d)
            self.R.append(len(self.D) - 1)

    def build(self, root=1):
        self.D.clear()
        self.R.clear()
        self.dfs(root, 0, 0)
        self.st.build(self.D)

    def lca(self, u, v):
        left = min(self.R[u], self.R[v])
        right = max(self.R[u], self.R[v])
        return self.st.query(self.D, left, right)

需要注意的细节

事实上，以上代码存在一个相对严重的问题，就是如果树不是一颗完全二叉树，会导致RMQ算法的结果错误。解决方案有很多，以下给出其中一个修改方案。我们可以在欧拉巡回序列中记录每个节点的深度和出现位置，之后将这两个元素拼接成一个二元组。对于ST算法中的比较操作，我们只需要比较这两个元素即可。这样我们得到的就是深度最小的节点，而深度最小的节点即为两个节点的最低共同祖先。

代码改进

以下是对原有代码的改进：

from collections import defaultdict
import math

class ST:
    def __init__(self):
        self.st = None

    def build(self, arr):
        n = len(arr)
        k = int(math.log2(n)) + 1
        self.st = [[(0, 0) for j in range(k)] for i in range(n)]

        for i in range(n):
            self.st[i][0] = arr[i]

        for j in range(1, k):
            for i in range(n - (1 << j) + 1):
                if self.st[i][j - 1][0] < self.st[i + (1 << (j - 1))][j - 1][0]:
                    self.st[i][j] = self.st[i][j - 1]
                else:
                    self.st[i][j] = self.st[i + (1 << (j - 1))][j - 1]

    def query(self, l, r):
        k = int(math.log2(r - l + 1))
        if self.st[l][k][0] < self.st[r - (1 << k) + 1][k][0]:
            return self.st[l][k]
        else:
            return self.st[r - (1 << k) + 1][k]

class LCA:
    def __init__(self, tree):
        self.depth = []
        self.euler = []
        self.first = []
        self.T = tree
        self.st = ST()

    def dfs(self, u, p, d):
        self.first[u] = len(self.euler)
        self.euler.append((d, u))
        self.depth.append(d)

        for v in self.T[u]:
            if v == p:
                continue
            self.dfs(v, u, d + 1)
            self.euler.append((d, u))
            self.depth.append(d)

    def build(self, root=1):
        self.first = [-1 for _ in range(len(self.T) + 1)]
        self.depth.clear()
        self.euler.clear()
        self.dfs(root, 0, 0)
        self.st.build(self.euler)

    def lca(self, u, v):
        left = self.first[u]
        right = self.first[v]
        if left > right:
            left, right = right, left
        return self.st.query(left, right)[1]

在以上代码中，我们使用了Python内置的collections模块来创建一个默认值为list的字典，来存储每个节点的子节点。为了处理树更加方便，我们在初始化中设置了一个默认的根节点，因为一般的二叉树都会在根节点处连接。对于RMQ算法，我们采用了记录深度和出现位置的元组，并在查询时比较两个元素的大小来实现。最后，我们解决了本算法的一个容错性问题，使得算法更加完备。