字符串的最长回文子串——Manacher算法

问题

对于给定的字符串，求算其最长的回文子串 。

Manacher算法

在学习算法时候，发现非常有趣的一个算法，除了它的名字（马拉车算法）很有意思，在去掉重复计算的子串上也有一定的借鉴意义。

消除奇偶回文串的影响，在字符串中间隔插入‘#’，可以将奇偶回文串都变成奇数回文串，方便进行计算：

s = '$' + '#' + '#'.join(s) + '#' + '\0'

在新的字符串中，我们令 r[i] 为以 i 为中心的回文子串半径，我们在纸上写一写可以发现，这个回文半径与原字符串中以 i 为中心的回文子串相差为 1，也就是：

 ansLen = r[i] - 1

之后，进入算法的主要内容。

设 maxRight 为目前查找到回文串中能够触及的母串最右边，我们令回文串的中心为 maxPos。对于当下求算的回文中心 i，必然存在 i > maxPos，因为 maxPos 我们已经找过了嘛。
这个时候存在几种情况，在这些情况中以 i 为中心的回文串被之前内容计算过的情况不同（提高效率的方法就是不再进行已经计算过的内容）。

1. i < maxRight；该情况意味着在 maxPos 回文串中，i 存在对称的 j，且 j 的回文半径在之前已经求过了，那么我们可以求出 r[i] 被重复计算过的部分半径，即r[i] = min(r[2 * maxPos - i], maxRight - i)；
   那，这是为什么呢？因为 i 与 j 对称，那能够想到 r[j] 与 r[i] 可能是一样的，但如果 j 的字串对称过来超过了我们的 maxRight，超过部分就不和 i 两边的字符对称了，因此这个对称半径的大小需要在 maxRight 内。
2. i >= maxRight；如果 i 超过了 maxRight，那必然没有对称情况了，令 r[i] = 1是非常明确的了。

确定跳过重复计算的部分后，就可以从 i 为中心，r[i] 为已知半径向外进行逐个的扩张了，即：

while s[i - r[i]] == s[i + r[i]]: r[i] += 1

最后，我们要以当前 i 查找到的回文子串对 maxPos 和 maxRight 进行更新，当然也少不了我们需要的结果 ansLen 了：

if r[i] + i > maxRight:
	maxPos = i
	maxRight = r[i] + i

if ansLen < r[i] - 1:
	ansLen = r[i] - 1

算法代码

class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        s = '$' + '#' + '#'.join(s) + '#' + '\0'
        	# 前后加上不同字符能够使中心对称时不需要进行边界判断
        
        r = [0] * len(s)

        #print(r)

        maxRight = 0
        maxPos = 0

        ansLen = -1
        ansPos = 0

        for i in range(1, len(s) - 1):
            if i < maxRight:
                r[i] = min(r[2 * maxPos - i], maxRight - i)
            else:
                r[i] = 1
            
            while s[i - r[i]] == s[i + r[i]]:
                r[i] += 1
            
            if r[i] + i > maxRight:
                maxPos = i
                maxRight = r[i] + i
            
            if ansLen < r[i] - 1:
                ansLen = r[i] - 1
                ansPos = i
    
        return s[ansPos - ansLen + 1: ansPos + ansLen].replace('#', '')