给定字符串中连续出现的不同子字符串的计数

在字符串处理中，有时候需要计算给定字符串中出现了多少种不同的子字符串。比如，对于字符串 "aab"，它所包含的不同子字符串为 "a", "aa", "b", "ab"，总共有四种不同的子字符串。

以下是一个计算给定字符串中不同子字符串数量的 Python 代码片段：

def count_distinct_substrings(string):
    substrings = set()
    for i in range(len(string)):
        for j in range(i + 1, len(string) + 1):
            substrings.add(string[i:j])
    return len(substrings)

这段代码的时间复杂度是 $O(n^3)$，其中 $n$ 为字符串的长度。这是因为它使用了两层循环来枚举所有可能的子字符串。如果字符串的长度很大，这个算法可能会非常慢。

下面介绍两种更高效的算法。

算法一

这个算法基于 trie 数据结构。它的时间复杂度为 $O(n^2)$。

首先，我们将字符串转换成 trie 树。执行这个步骤的时间复杂度为 $O(n^2)$。然后，我们枚举 trie 树中的所有从根节点到叶子节点路径，每一条路径代表一个子字符串。因为 trie 树中有 $n$ 个节点，有关于 $n$ 条从根节点到叶子节点的路径，所以这个步骤的时间复杂度为 $O(n^2)$。

以下是一个计算给定字符串中不同子字符串数量的 Python 代码片段，它使用 trie 数据结构：

class TrieNode:
    def __init__(self):
        self.children = {}
        self.is_word = False

def count_distinct_substrings(string):
    root = TrieNode()
    for i in range(len(string)):
        node = root
        for j in range(i, len(string)):
            if string[j] not in node.children:
                node.children[string[j]] = TrieNode()
            node = node.children[string[j]]
            if node.is_word:
                break
            node.is_word = True
    count = 0
    stack = [root]
    while stack:
        node = stack.pop()
        if node.is_word:
            count += 1
        for child in node.children.values():
            stack.append(child)
    return count

算法二

这个算法的时间复杂度为 $O(n)$。

我们可以使用一个哈希表来存储以某个字符结尾的最长子字符串的长度。遍历整个字符串，对于其中的每一个字符，我们都更新哈希表中以该字符结尾的最长子字符串的长度。

具体来说，假设我们已经扫描完了前 $i$ 个字符，哈希表中记录了以某个字符结尾的最长子字符串的长度为 $l_i$。我们考虑字符串中下一个字符 $c_{i+1}$。如果 $c_{i+1}$ 没有出现过，那么对应的最长子字符串长度为 $l_i+1$。如果 $c_{i+1}$ 已经出现过，并且它出现的位置与当前最长子字符串中的最后一个字符的位置的距离大于等于 $l_i$，那么对应的最长子字符串长度也是 $l_i+1$。否则，当前最长子字符串的结尾就必须移动到 $c_{i+1}$ 的前面一位，并且对应的最长子字符串长度将减少。具体来说，就是我们需要从当前最长子字符串的倒数第二个字符开始向前移动，直到我们找到了一个与 $c_{i+1}$ 不相同的字符。这个过程就类似于 KMP 算法中的跳转操作。

以下是一个计算给定字符串中不同子字符串数量的 Python 代码片段，它使用哈希表：

def count_distinct_substrings(string):
    last_occurrence = {}
    longest_substring_lengths = [0] * len(string)
    longest = 0
    for i, c in enumerate(string):
        if c in last_occurrence:
            distance = i - last_occurrence[c]
            if distance > longest:
                longest += 1
            else:
                longest = distance
        else:
            longest += 1
        last_occurrence[c] = i
        longest_substring_lengths[i] = longest
    return sum(longest_substring_lengths)

无论哪种算法，它们的时间复杂度都优于 $O(n^3)$。具体来说，算法一的时间复杂度为 $O(n^2)$ 或者 $O(n \log n)$，而算法二的时间复杂度为 $O(n)$。如果给定字符串的长度很大，并且需要多次计算不同子字符串的数量，那么使用算法二可以显著提高程序的运行效率。