字符串的字典序最大子字符串

在字符串中，字典序指的是字符串按照字母表排列的顺序。例如，"apple" 及其子串的字典序最大子字符串为"pple"，因为在所有以"a"开头的子字符串中，"pple" 字典序最大。

现在给定一个字符串，求它的字典序最大的子字符串。下面将介绍三种不同的解法。

解法一：暴力枚举

对于一个长度为 n 的字符串，我们可以枚举所有子串，并依次比较它们的字典序。最终得到字典序最大的子串。

时间复杂度为 O(n^3)，不适用于较长的字符串。

def max_lexicographic_substring(s):
    n = len(s)
    ans = ""
    for i in range(n):
        for j in range(i, n):
            if s[i:j+1] > ans:
                ans = s[i:j+1]
    return ans

解法二：后缀数组

通过构造字符串的后缀数组，我们可以很容易地找到字典序最大的子串。具体地，在后缀数组中，所有以当前字符开头的后缀都排在一起。我们可以从后往前扫描后缀数组上的所有后缀，找到最靠前的一个后缀，它的下标加上它的长度就是我们要找的字典序最大的子串的起始下标。

时间复杂度为 O(nlogn)，适用于较长的字符串。

def max_lexicographic_substring(s):
    n = len(s)
    suffix_array = sorted(range(n), key=lambda i: s[i:])
    ans = ""
    for i in range(n-1, -1, -1):
        idx = suffix_array[i]
        if idx + len(ans) > n or s[idx:idx+len(ans)] >= ans:
            ans = s[idx:] + ans
    return ans

解法三：后缀树

后缀树是字符串匹配算法中的一种高级数据结构，通过将所有后缀插入到树中构造得到。与后缀数组相比，后缀树可以支持更加丰富的字符串操作。在后缀树中，我们可以从根节点开始，按照字典序往下走，直到遇到一个节点，它的任意一个子节点对应的后缀都没有后缀右端点比当前后缀右端点更小。这个节点对应的后缀就是字典序最大的子串。

时间复杂度为 O(n)，但实现相对较为复杂。

def max_lexicographic_substring(s):
    class Node(object):
        def __init__(self, l, r):
            self.l = l
            self.r = r
            self.children = []
        def add_child(self, node):
            self.children.append(node)
        def __lt__(self, other):
            return s[self.l:self.r] > s[other.l:other.r]
        
    def build_suffix_tree():
        n = len(s)
        root = Node(-1, -1)
        root.add_child(Node(0, n))
        for i in range(1, n):
            j = 0
            curr = root
            while j < len(curr.children):
                child = curr.children[j]
                if s[child.l] == s[i]:
                    k = child.l + 1
                    while k < child.r and s[k] == s[i+k-child.l]:
                        k += 1
                    if k == child.r:
                        curr = child
                        j = 0
                        continue
                    elif k == child.l+1:
                        curr = child
                        j += 1
                        continue
                    else:
                        mid = Node(child.l, k)
                        child.l = k
                        mid.add_child(child)
                        curr.children[j] = mid
                        curr = mid
                elif s[child.l] < s[i]:
                    j += 1
                    continue
                else:
                    mid = Node(child.l, child.l+1)
                    mid.add_child(child)
                    curr.children[j] = mid
                    curr = mid
            leaf = Node(i, n)
            curr.add_child(leaf)
        
        return root
    
    def dfs(node, depth):
        if not node.children:
            return node.l
        else:
            return dfs(max(node.children), depth+1)
        
    root = build_suffix_tree()
    start = dfs(root, 0)
    return s[start:]

以上三种解法分别通过枚举、后缀数组、后缀树来找到字符串的字典序最大子字符串。根据字符串的长度以及实际应用场景的不同，我们可以选择不同的解法。