使用RMQ在二叉树中查找LCA

RMQ（Range Minimum/Maximum Query）是一种经典的数据结构，用于在数组中快速查询一段区间内的最小/最大值。

在二叉树中查找最近公共祖先（Lowest Common Ancestor，LCA）也是一种常见的问题，可以使用RMQ数据结构来解决。

算法思路

如何将二叉树转换成数组，使得RMQ算法可以使用呢？一种常见的方法是使用欧拉遍历（Euler Tour），将二叉树转换成一维数组。欧拉遍历先走一遍前序遍历，记录下每个节点第一次出现的时间，再走一遍后序遍历，记录下每个节点最后一次出现的时间。这样就可以用一个数组来表示整个二叉树，RMQ算法就可以在这个数组上查询LCA了。

代码实现

以下是使用欧拉遍历和RMQ算法在二叉树中查找LCA的代码实现（使用Python语言）：

class RMQ:
    def __init__(self, arr):
        self.n = len(arr)
        self.logn = (self.n - 1).bit_length()
        self.st = [[0] * self.logn for _ in range(self.n)]
        
        for i in range(self.n):
            self.st[i][0] = arr[i]
        
        for j in range(1, self.logn):
            for i in range(self.n - (1 << j) + 1):
                self.st[i][j] = min(self.st[i][j - 1], self.st[i + (1 << (j - 1))][j - 1])
        
    def query(self, l, r):
        k = (r - l).bit_length() - 1
        return min(self.st[l][k], self.st[r - (1 << k)][k])


class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right


def build_euler_tour(root, arr, time):
    if not root:
        return
    arr.append(root.val)
    time.append(len(arr) - 1)
    build_euler_tour(root.left, arr, time)
    arr.append(root.val)
    time.append(len(arr) - 1)
    build_euler_tour(root.right, arr, time)
    arr.append(root.val)
    time.append(len(arr) - 1)


class LCA:
    def __init__(self, root):
        self.arr = []
        self.time = []
        build_euler_tour(root, self.arr, self.time)
        self.rmq = RMQ(self.arr)
        self.graph = {}
        self.visited = set()

    def find_lca(self, u, v):
        if u in self.visited and v in self.visited:
            return self.rmq.query(min(self.time[u], self.time[v]), max(self.time[u], self.time[v]) + 1)
        
        if u not in self.graph:
            self.graph[u] = []
            u_node = None
            for i in range(len(self.arr)):
                if self.arr[i] == u:
                    u_node = i
                    break
            for v_node in range(u_node - 1, -1, -1):
                if self.arr[v_node] == u:
                    continue
                if self.arr[v_node] in self.graph:
                    self.graph[u].extend(self.graph[self.arr[v_node]])
                    break
                v = self.arr[v_node]
                if v in self.visited:
                    self.graph[u].append(v)
                    break
                self.graph[u].append(v)
            self.graph[u].append(u)
            self.graph[u].extend(reversed(self.graph[u]))
        
        for w in self.graph[u]:
            self.visited.add(w)
            if w == v:
                return w
            lca = self.find_lca(w, v)
            if lca is not None:
                return lca
        return None

总结

RMQ算法可以在数组中快速查询一段区间内的最小/最大值。在二叉树中查找LCA问题可以使用欧拉遍历和RMQ算法来解决，将二叉树转换成一维数组，再在数组上使用RMQ算法进行查询。欧拉遍历可以使用前序遍历和后序遍历来完成。