最长的重复和不重叠子字符串

当我们处理字符串的时候，经常需要找出其中最长的重复子串或者最长的不重叠子串。这在字符串匹配、数据压缩等领域都有广泛的应用。

最长的重复子串

最长的重复子串是指一个字符串中出现至少两次，并且长度最长的子串。这个问题可以通过后缀数组（suffix array）来解决。下面是算法的步骤和代码片段。

算法步骤

1. 构建后缀数组。
2. 根据后缀数组和原始字符串计算 LCP（最长公共前缀）数组。
3. 在 LCP 数组中找到最大的 LCP 值，这个值对应的后缀之间的字符串就是最长的重复子串。

代码片段

def find_longest_repeated_substring(s):
    n = len(s)
    suffixes = [(s[i:], i) for i in range(n)]
    suffixes.sort()
    lcp = [0] * n
    for i in range(n-1):
        x, y = suffixes[i][1], suffixes[i+1][1]
        while x < n and y < n and s[x] == s[y]:
            lcp[i] += 1
            x += 1
            y += 1
    max_lcp = max(lcp)
    if max_lcp == 0:
        return None
    else:
        i = lcp.index(max_lcp)
        return s[suffixes[i][1]:suffixes[i][1]+max_lcp]

这个算法的时间复杂度是 O(n log n)，其中 n 是字符串的长度。

最长的不重叠子串

最长的不重叠子串是指一个字符串中不包含重复字符，并且长度最长的子串。这个问题可以通过动态规划来解决。下面是算法的步骤和代码片段。

算法步骤

假设 f[i] 表示以第 i 个字符结尾的最长不重叠子串长度。则有：

1. 如果字符 s[i] 之前没有出现过，则 f[i] = f[i-1] + 1。
2. 如果字符 s[i] 之前出现过，并且上次出现的位置在 f[i-1] 之前，则 f[i] = f[i-1] + 1。
3. 如果字符 s[i] 之前出现过，并且上次出现的位置在 f[i-1] 之后，则 f[i] = i - last。

其中，last 表示 s[i] 上一次出现的位置。

代码片段

def find_longest_non_overlap_substring(s):
    n = len(s)
    f = [1] * n
    last = {s[0]: 0}
    for i in range(1, n):
        if s[i] not in last:
            f[i] = f[i-1] + 1
        elif last[s[i]] < i - f[i-1]:
            f[i] = f[i-1] + 1
        else:
            f[i] = i - last[s[i]]
        last[s[i]] = i
    max_len = max(f)
    if max_len == 1:
        return None
    else:
        i = f.index(max_len)
        return s[i-max_len+1:i+1]

这个算法的时间复杂度是 O(n)，其中 n 是字符串的长度。