Manacher's algorithm: 最长回文子串算法

Manacher 算法是时间、空间复杂度都为 O(n) 的解决 Longest palindromic substring（最长回文子串）的算法。回文串是中心对称的串，比如 'abcba'、'abccba'。那么最长回文子串顾名思义，就是求一个序列中的子串中，最长的回文串。本文最后用 Python 实现算法，为了方便理解，文中出现的数学式也采用 py 的记法。

在 leetcode 上用时间复杂度 O(n**2)、空间复杂度 O(1) 的算法做完这道题之后，搜了一下发现有 O(n) 的算法。可惜英文 wikipedia 上的描述太抽象，中文介绍又没找到说的很明白的，于是就下决心自己写一篇中文比较清楚的。我弄明白这个算法是通过 leetcode 上的一篇文章，也就是 wikipedia 词条中第一个外部链接。链接在此（http://articles.leetcode.com/2011/11/longest-palindromic-substring-part-ii.html），图文并茂，很容易懂（我就是没通读文章，主要看图和图的说明就弄懂了）。如果还是觉得读英文费劲的话，那接着读我这篇吧。

Manacher 算法的最终目的，是根据原串构造出一个新队列，内容是以该点为中心，最长的对称长度。为了解决对称奇偶性的问题（比如 aba 和 abba，常规算法需要分成两种情况），首先是构造一个辅助串，在首尾和任何两字符中间插入一个相同的字符。比如串 ababa，构造成 #a#b#a#b#a#。接下来就是构造一个新队列，里面记录以该点为中心的最长对称长度：

S1 = ababa
T1 = # a # b # a # b # a #

P1 = 0 1 0 3 0 5 0 3 0 1 0

S2 = abaaba
T2 = # a # b # a # a # b # a #
P2 = 0 1 0 3 0 1 6 1 0 3 0 1 0

那么，具体该如何构造序列 P 呢？首先，去除串长不大于1的 corner case，我们总能得到 P 前两个元素的值。

T = # ? # ...

P = 0 1 ? ...

然后，我们就可以根据已经知道的 P 元素和 T 中的元素一步一步求出后面的值了。问题分解成：已知 P[:i]，求 P[i] 的问题。

接下来，就要讨论一下回文子使 P 具有哪些性质。下面用 leetcode 文章中的例子，s = 'babcbabcbaccba'（len(s) == 14，t = '#b#a#b#c#b#a#b#c#b#a#c#c#b#a#'，len(t) == len(s)*2+1 == 29）。

---

1.核心算法

如下图，假设当我们已知 T、P[:8] 时，求 P[9]。

     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4  5 6 7 8 9 0 1 2 3 4 5 6 7 8
T = [# b # a # b # c # b # a # b #] c # b # a # c # c # b # a #

P = [0 1 0 3 0 1 0 7 0 ? ...

观察我用方括号包起来的部分，正是以 T[7] 为中心，7为长度构成的回文。直观来看，由于回文是对称的结构，P 中的元素值似乎也应该是根据中心对称的，那么 P[9] = P[5] = 1，从结果上来看也是正确的。那么接下来往后填，很快你会发现这个结论有错误。

     0 1  2 3 4 5 6  7 8 9 0 1 2 3 4  5 6 7 8 9 0 1 2 3 4 5 6 7 8
T = {# b [# a # b #} c # b # a # b #] c # b # a # c # c # b # a #

P =  0 1  0 3 0 1 0  7 0 1 0 ? ...
i = 11
center = 7
right = 14
mirror = 3

当填到 P[11] 时，红色字部分是 T[7] 为中心7为长度的回文，而黄色背景色部分，是以 P[11] 为中心9为长度的回文。按照上一段的结论，我们应该填入 P[7-(11-7)] = P[3] = 3，但实际上应该填入9。这是怎么回事呢？

为了说清楚这个问题，先来定义一些变量。首先 center 是已知的对称点，right 是已知对称点的最右端，当前求的 P 索引为 i，i 关于 center 的对称点索引是 mirror。上面在求 P[9] 和 P[11] 时，center == 7，right == 14。接下来，让我们接着往后扫描，看一下另外一个情况：已知 center==11, right==20, 求 P[15]。

     0 1  2 3 4 5 6 7 8 9 0 1 2 3 4  5 6 7 8 9 0  1 2 3 4 5 6 7 8
T = {# b [# a # b # c # b # a # b #} c # b # a #] c # c # b # a #

P =  0 1  0 3 0 1 0 7 0 1 0 9 0 1 0  ? ...
i = 15
center = 11
right = 20
mirror = 7

观察这两个过程，不难发现，发生这种情况的原因，是 mirror 为中心点的回文（示例中用黄色背景标注，{}之间的回文），其范围超过了以 center 为中心点的回文的左端（红字标注，[] 之间的回文）。而凡是 P[i] == P[mirror] 的回文，其 P[mirror] 的范围都不超过 P[center] 的范围。具体来说，就是 P[mirror] 的左端不超过 P[center] 的左端。

那么怎么来判断呢？mirror 到 P[center] 左侧的长度是 right-i，如果这段长度不小于 P[mirror] 的话，P[mirror] 就在 P[center] 的范围内。如果没想明白的话，下面是用笨方法来的数学推导：

PalindromeLeftOf(mirror) = mirror - P[mirror]
PalindromeLeftOf(center) = center - (right - center)
mirror = center - (i - center)

if leftOf(mirror) is inside P
PalindromeLeftOf(center) <= PalindromeLeftOf(mirror)  =>
center - (right - center) <= mirror - P[mirror]   =>
center - (right - center) <= center - (i- center) - P[mirror] =>
-right <= -i - P[mirror] =>
P[mirror] <= right - i

需要注意的是，由于 P[mirror] == right - i  情况的存在，也就是 P[mirror] 的左端与 P[center] 的左端重合，这也就意味着 P[i] 的当前右端为 right，P[i] 也就有可能会比 P[mirror] 长，这种情况下仍需对 P[i] 进行扩展操作。

到目前为止，通过已知的 p[:i] 用 O(1) 的操作计算得出 p[i] 的结果的过程就讲完了。这个过程是 Manacher 算法的核心，也是最难理解的部分，剩下的过程就不复杂了。

---

2.扩展 P 的过程

现在再回到本文一开始，当我们拿到源数据时，马上可以得到的是 P 的前两项。

T = # b # a # b # c # b # a # b # c # b # a # c # c # b # a #
P = 0 1 ? ...
center = 1
right = 2

开始计算，i=2, mirror=0, P[mirror] == right-i。按照上一节的结论，需要对 P 进行扩展，也就是对 T[i+n] == T[i-n] 进行依次判断。不幸的是，第一次就失败了，于是我们进入下一步：

T = # b # a # b # c # b # a # b # c # b # a # c # c # b # a #
P = 0 1 0 ? ...
i = 3
center = ?
right = 2
mirror =?

不论是以 P[1] 为中心，还是 P[2] 为中心，right 的值总是2，而下一步 i > right，这时不论哪个是中心，都不存在 i 的对称点了。那这种情况下，我们就从零开始吧：

    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8
T = # b # a # b # c # b # a # b # c # b # a # c # c # b # a #
P = 0 1 0 3 ? ...
i = 4
center = 3
right = 6
mirror = 2

这次我们得到了新的 center、right，并且 right 比原来的大，那么就用新的来替换老的。

到现在为止，i > right 和 P[mirror] <= right - i 两种情况都已经讨论完了，那么还剩最后一种。

---

3.最后一步

现在还剩下的情况就剩 i <= right and P[mirror] > right - i 这一种了。既然是要扩展 P，那么从零开始似乎也没什么不妥的。先考虑下面的情况：

    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8
T = # b # a # b # c # b # a # b # c # b # a # c # c # b # a #
P = 0 1 0 3 0 1 0 7 0 1 0 9 0 1 0 ? ...
i = 15
center = 11
right = 20
mirror = 7

这种情况前面已经见过一次了 P[mirror] > right-i。这时，我们需要扩展 P[15]，但是需要从 n=0 开始判断 P[15+n] == P[15-n] 成立吗？因为 P[mirror]=7 > right-i=5，由于当 0<=n<=7 时，有 P[mirror-n] == P[mirror+n]，而当 0<=n<=5 时有 P[mirror-n] == P[i+n]，所以不难得出当 0<=n<=5 时有 P[i+n] == P[i-n]。换句话说，由于 P[mirror] 的回文范围超过了 P[center] 的范围，所以 P[i] 在不超过 P[center] 的范围内一定是回文。所以这时我们不需要从0开始判断，而只要从 right+1 开始判断就可以了。

---

 

代码

再上代码之前，首先对上述情况进行重分类和合并。

1. 直接用 O(1) 操作得到 P[i]，不需要对 P 进行扩展，也不需要扫描 T，center、right 的值也不变。

2. 需要对 P 进行扩展，这时会从 T[right+1] 开始扫描，同时也需要更新 center、right 的值。

情况1的复杂度为 O(1)，情况2的复杂度虽然为 O(n)，但由于算法的实现，能够保证从左到右扫描 T 时，每次都从 right+1 开始，并且扫描的最右端成为 right，这样就能够保证从左到右访问 T 中的每个元素不超过2次。所以，Manacher 算法的复杂度是 O(n)。

那么按照我的分类，贴上一段 Python 代码的实现，可能会跟你见到的标准实现长得不太一样。

 1 # @param {string} s

 2 # @return {string}

 3 def longestPalindrome(s):

 4     if len(s) <= 1:

 5         return s

 6 

 7     THE_ANSWER = 42

 8     T = [THE_ANSWER]

 9     for c in s:

10         T.append(c)

11         T.append(THE_ANSWER)

12 

13     c, r, size = 1, 2, len(T)

14     P = [0, 1] + [None] * (size-2)

15     maxIndex, maxCount = 0, 1

16     for i in xrange(2, size):

17         m = c*2 - i     # mirror = center - (i - center)

18         if r > i and P[m] < r-i:

19             # case 1, just set P[i] <- P[m]

20             P[i] = P[m]

21             continue

22 

23         # case 2, expand P

24         count = min(i, size-i-1) # n's limit

25         # scan, from if r <= i then T[i+1] else T[right+1]

26         for n in xrange((1 if r <= i else r+1-i), count+1):

27             if T[i+n] != T[i-n]:

28                 count = n-1

29                 break

30                 

31         # update center and right, save P[i], compare with the max

32         c = i

33         r = i+count

34         P[i] = count

35         if count > maxCount:

36             maxCount = count

37             maxIndex = i-count

38 

39     maxIndex = maxIndex // 2

40     return s[maxIndex:maxIndex+maxCount]