计算字符串中的所有回文子字符串

本套装提供了多种不同的算法实现，用于计算给定字符串中的所有回文子字符串。这些算法包括：暴力枚举、中心扩散、Manacher算法等。你可以根据自己的需求选择不同的算法来解决问题。

算法实现

算法1：暴力枚举

暴力枚举算法非常简单，遍历所有子串，并判断是否是回文子串。时间复杂度为O(n^3)。下面是实现代码：

def find_palindromic_substrings(s):
    res = []
    n = len(s)
    for i in range(n):
        for j in range(i + 1, n + 1):
            if s[i:j] == s[i:j][::-1]:
                res.append(s[i:j])
    return res

算法2：中心扩散

中心扩散是一种比暴力枚举更加高效的算法，时间复杂度为O(n^2)。具体思路是枚举所有的回文中心，然后向两边扩展，直到无法扩展为止。下面是实现代码：

def find_palindromic_substrings(s):
    res = []
    n = len(s)
    for i in range(n):
        # 回文中心为单个字符
        l, r = i, i
        while l >= 0 and r < n and s[l] == s[r]:
            res.append(s[l:r+1])
            l -= 1
            r += 1
        # 回文中心为两个字符
        l, r = i, i+1
        while l >= 0 and r < n and s[l] == s[r]:
            res.append(s[l:r+1])
            l -= 1
            r += 1
    return res

算法3：Manacher算法

Manacher算法是一种时间复杂度为O(n)的算法，是目前最优的算法。具体思路是利用回文中心的对称性，在每个位置记录当前能够扩展的最大半径，然后再利用这些信息来计算出所有的回文子串。下面是实现代码：

def find_palindromic_substrings(s):
    s = '#' + '#'.join(s) + '#'
    n = len(s)
    p = [0] * n
    max_right, center = 0, 0
    for i in range(1, n - 1):
        if i < max_right:
            p[i] = min(max_right - i, p[2 * center - i])
        while i + p[i] + 1 < n and i - p[i] - 1 >= 0 and \
                s[i + p[i] + 1] == s[i - p[i] - 1]:
            p[i] += 1
        if i + p[i] > max_right:
            max_right = i + p[i]
            center = i
    res = []
    for i, x in enumerate(p):
        if x == 0:
            continue
        if i - x == 0 or i + x == n - 1:
            continue
        if i % 2 == 0:
            res.append(s[i-x:i+x+1].replace('#', ''))
        else:
            res.append(s[i-x:i+x+1])
    return res

使用示例

下面是一个简单的示例代码：

s = 'babad'
print(find_palindromic_substrings(s))  # ['bab', 'aba']

总结

本套装提供了多种不同的算法实现，用于计算给定字符串中的所有回文子字符串。这些算法包括：暴力枚举、中心扩散、Manacher算法等。你可以根据自己的需求选择不同的算法来解决问题。