后缀树应用程序5 - 最长公共子串

后缀树可以用来解决多种字符串操作问题，其中之一就是找到两个或多个字符串的最长公共子串（Longest Common Substring）。最长公共子串是一组字符串中最长的共同字符串。

如何使用后缀树找到最长公共子串

1. 构建一个后缀树。将两个字符串合并，并在结尾处插入一个特殊字符。比如可以选择$。

2. 找到这个后缀树中最深的内部节点，该节点的所有后代都是输入字符串的后缀，而且每个后代都在两个字符串中出现过。找到这个节点的过程中，需要确定每个节点所代表的字符串在两个字符串中的出现情况。

3. 找到最长的共同字符串。访问最深的节点，并通过深度优先搜索遍历其所有后代，直到找到一个节点有两个以上的孩子节点。

4. 返回最长共同子串。

代码示例

# 定义一个后缀树的节点
class Node:
    def __init__(self, start, end):
        self.start = start  # 后缀的起始位置
        self.end = end  # 后缀的结束位置
        self.edges = {}  # 指向其他节点的边

    def __repr__(self):
        return f"Node({self.start}, {self.end})"

# 构建后缀树的函数
def build_suffix_tree(text):
    n = len(text)
    root = Node(-1, -1)
    root.edges[text[0]] = Node(0, n-1)

    for i in range(1, n):
        current = root
        j = i
        while j < n:
            if text[j] in current.edges:
                child = current.edges[text[j]]
                k = child.start
                while k <= child.end and text[j] == text[k]:
                    j += 1
                    k += 1
                if k > child.end:
                    current = child
                    continue
                else:
                    # 相交分裂（Split the edge）
                    new_node = Node(child.start, k-1)
                    child.start = k
                    new_node.edges[text[k]] = child
                    current.edges[text[j]] = new_node

            else:
                current.edges[text[j]] = Node(j, n-1)
                
            break
    return root

# 找到最深的节点的函数
def deepest_common_node(root, s1, s2):
    deepest, depth = None, 0
    stack = [(root, 0)]

    while stack:
        node, count = stack.pop()

        if node.start >= 0:
            if count == 2 and node.start < len(s1) and node.start < len(s2):
                return deepest
            elif count > depth:
                deepest, depth = node, count
        
        for edge in node.edges:
            if edge == s1[node.start+count] or edge == s2[node.start+count]:
                stack.append((node.edges[edge], count+1))

    return deepest

# 找最长公共子串的函数
def longest_common_substring(s1, s2):
    text = s1 + "$" + s2 + "#"
    root = build_suffix_tree(text)
    deepest_node = deepest_common_node(root, s1, s2)

    return s1[deepest_node.start:deepest_node.end+1]


# 测试
s1 = "hello world"
s2 = "ohllewdlor"
print(longest_common_substring(s1, s2))  # 输出"hello"

代码解释：

• build_suffix_tree函数实现了构建后缀树的功能。
• deepest_common_node函数用于查找最深的节点，其所有后代都在两个字符串中出现过。
• longest_common_substring函数通过最深的公共节点，在两个字符串中找到最长的公共子串。

总结

通过这个例子，我们可以看到后缀树在查找最长公共子串方面的优越性。其时间复杂度为$O(m+n)$，其中$m$和$n$分别为两个字符串的长度。如果使用传统的字符串匹配算法，时间复杂度为$O(mn)$，远低于后缀树的效率。