马拉车算法:https://articles.leetcode.com/longest-palindromic-substring-part-ii/
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]