原文链接:http://blog.csdn.net/linulysses/article/details/5634104
一个序列(字符串)S=a1a2...an 的倒置 S' 为 anan-1...a1。而 S 的子串定义为 S 中任何连续的一部分,如 aiai+1...aj 是 S 的一个子串,但aiai+2... 则不是 S 的子串。如果一个序列 S=S',则 S 称为回文序列。本文接下来将研究一个有趣的问题:给定一个序列 S,找出 S 中最长的回文子串。
在详细分析各个算法之前,先给出一个概览:简单的暴力算法时间复杂度为 Ɵ(n3)。经过仔细分析,可以通过动态规划把复杂度降至 O(n2)。但是,令人兴奋的是,存在线性复杂度,即 O(n) 的算法!
一、暴力算法
按照惯例,先分析一下暴力的算法:对 S 的每个子串,先判断其是否为回文,如果是,则跟已知的最长回文子串相比较,并保存其中最长的那个。
- set longest_parlindrome to empty string
- for each substring P of the string S do
- if P is a palindrome
- if P.length > longest_parlindrome.length then
- longest_parlindrome := P
- end if
- end if
- end for
- output longest_parlindrome
长度为 n 的字符串一共有 O(n2) 个子串,判断一个子串是否为回文串平均需要 O(n) 时间,因此,该算法的复杂度为 O(n3) 。当然,可以在算法中加入剪枝,例如,当子串 P 的长度比已知最长回文子串的长度小时,可以不必进行检查是否为回文串了。但这个并不能带来时间复杂度上质的变化。
二、动态规划
仔细分析该暴力算法,可以发现,该算法中存在很多重复计算。例如,当子串 P 不是回文时,xPy 也不可能是回文。再如,子串 xPx 是否为回文当且仅当 P 是回文。这后面的例子有点动态规划的味道了。沿着这个方向,可以比较容易的设计出动态规划的算法。首先,用 LP[i][j] 表示子串 aiai+1...aj 是否为回文。则
LP[i][j] = true,如果 i >= j,即单字符的串和空串都是回文;
LP[i][j] = true,如果 S[i] = S[j] 并且 LP[i+1][j-1] = true;
否则,LP[i][j] = false。
在填动态规划表时,按子串的长度从小到大进行。
- /* Use LP_start and LP_end to record the start and ending positions of the found longest parlindrome. */
- Assume S is not empty. If S is empty, just output S and return.
- LP_start := 1
- LP_end := 0
- for i from 2 to n do
- LP[i][i-1] := true
- end for
- for m from 1 to n do
- for i from 1 to n+1-m do
- j := i+m-1
- if i = j or (S[i] = S[j] and LP[i+1][j-1] = true) then
- LP[i][j] := true
- if LP_end - LP_start + 1 < m then
- LP_end := j
- LP_start := i
- end if
- else
- LP[i][j] := false
- end if
- end for
- end for
- output S[LP_start ~ LP_end]
可以看出,这个算法的时间复杂度为 O(n2)。相比较暴力算法,速度的提升来自检查每个子串是否为回文只需要 O(1) 的时间,而这在暴力算法中,最坏时平均是 O(n)。O(n2) 看起来好像是极限了,因为,毕竟搜索空间是 Ɵ(n2),即有 Ɵ(n2) 个子串。如果有线性复杂度的算法,那么将是比较神奇的,因为,这意味着不需要逐一检查每个子串!事实上,这个真的可以有,而已知有两个完全不同的算法达到线性复杂度,从而也是最优的算法:一个基于后缀树 (suffix tree);一个基于回文子串一个性质。
三、基于后缀树的线性算法
先来看看基于后缀树的算法。首先需要了解一下最长公共扩展:给定两个字符串 S1 和 S2,以及 S1 的一个后缀 t1和 S2 的一个后缀 t2,求 t1 和 t2 的最长公共前缀。这个问题之所以被称为最长公共扩展,是因为,如果 t1 的第一个字符在 S1 中位于 q1,t2 的第一个字符在 S2 中位于 q2,那么,最长公共扩展问题即为,求从 t1 开始在 S1 中向后扩展,同时从 t2 开始在 S2 中向后扩展,两个扩展中最长的公共部分。当 S1 和 S2 给定后,每个位置对 (q1,q2) 代表一个查询,查询对应着位置 q1 和 q2 的最长公共扩展。 举个例子,令 S1=abcdef,S2=efbcd,q1=2,q2=3,则 (q1,q2) 的最长公共扩展为 bcd。
现在,令 S1=S 和 S2=S',即 S 的倒置,n 为 S 的长度。如果有一个长度为 2k 的回文串是最大的,即没有更长的回文串包含它,若假设其中心的两个字符右的那个在 S 中位于 q+1,则中心左边的那个字符在 S' 中位于 n-q+1,并且,(q+1,n-q+1) 的长度为 k。反之,如果 (q+1,n-q+1) 的长度为 k,则在 S 中有一个长度为 2k 的,中心的左边位于 q 的偶数回文串。因此,如果我们遍历每个中心的左边,我们就可以找出每个中心对应的最长偶数回文的长度。用相似的方法可以求得每个中心对应的最长奇数回文串的长度,从而在这所有的 2n-1 个回文子串中找出最长那个。
现在,有 2n-1 个中心,因此,一共有 2n-1 个查询。如果算法的复杂度为 O(n),则每个查询须在 O(1) 时间内完成。这事儿看起来很悬,但真的能够做到!这是因为,存在一个神奇的算法,可以在 O(n) 的时间内建立起长度为 n 的字符串的后缀树。而且,一旦预先建立好 S1 和 S2 的后缀树,则对每个查询 (q1,q2),可以在 O(1) 的时间内确定其最长公共扩展。具体的算法参见《Algorithms on Strings, Trees and Sequences》第 198 页。这里,我摘抄了其中计算偶数回文的算法。
- /* Algorithm to compute all even length maximal parlindrome in S */
- 1. Create the reverse string S' from S and preprocess the two strings so that
- any longest common extension query can be solved in constant time.
- 2. For each q from 1 to n — 1, solve the longest common extension query for the index pair
- (q + 1,n — q + 1) in S and S', respectively. If the extension has nonzero length k, then
- there is a maximal palindrome of radius k left-centered at q.
四、一个简单的线性算法
个人认为后缀树是一个比较“重型”的数据结构,功能虽然强大,但线性建立后缀树的算法很是复杂。用它来解决最长回文子串问题,有点像杀鸡用了牛刀。事实上,有个非常简单的算法,可以在线性时间内计算出所有中心的最大回文串,从而求出最长的那个回文串。这个算法是本人在某国外的网站上看到的,链接在这里。因为未在任何中文网站上见到过,本人也不敢独享,于是在因此向大家详细介绍该算法。
先来说说回文的中心。对于奇数长度的回文,这个中心是惟一的;但对于偶数回文来说,从字符串本身看来,中心有两个相同的字符。当然,也可以理解为偶数回文的中心落在两个相邻的字符之间。为了统一起见和方便叙述,我们想像在 S 的开头、末尾和每两个相邻的字符之间插入一个特殊的字符(空隙),奇数回文的中心落在某个常规字符上,偶数回文的中心落在特殊字符(空隙)上。而且,在索引回文的中心的位置时,把特殊字符也计算在内。例如,假设 S = abcbbe,则把 S 想像成 _a_b_c_b_b_e_,其中下划线代表特殊字符。于是,回文 bcb 的中心为 c,其中位置索引为 6,而不是3,因为当我们索引中心时,把特殊字符也计算在内;另一个回文 bb 的中心为 _,其中心位置索引为 9。这样,所有子串,都有一个惟一的中心索引位置。不过,我们在索引 S 本身的字符位置时,依然只是参照实际上 S,而非想像中的带有特殊字符的 S。例如,当我们说 S[1],就只是指 S 的第一个字符,即 a,而 S[1~3] 则指其子串 abc。
在说明回文的一些性质前,先来看个例子:S = abababa。这个例子中,S[1~3],即开头的 aba 是一个回文,同时也是更大的回文,S[1~5] 及 S 本身的子串。对比 S[1~3]=aba 和 S[1~5]=ababa,可以发现,S[3~5] = S[1~3],且其关于 S[1~5] 的中心对称。这不是偶然的。可以证明,如果 X 是 Y 的一个真回文子串(即 X 不等于 Y),则存在它的关于 Y 的中心对称的对偶子串 X'=X。在上例中,若Y=S[1~5],X=S[1~3],则 X' = S[3~5]。精确地说,假设回文 Y 的中心位于 p,X 是 Y 的长度为 k 的真回文子串,其中心位于 p-d,则有一个长度也为 k 的真回文子串,其中心位于 p+d。如果用数组 Len[1~2n+1] 表示各个中心的最大回文串,即 Len[i] 表示中心位于 i 的最长的回文,则上述性质说明,
如果 回文 Y 的中心位于 p,且以 p-d (d>0) 为中心的最长回文 X 是 Y 的子串,则 Len[p+d] 至少不小于 Len[p-d],即 Len[p+d] >= Len[p-d]。
需要强调的是,X 必须是 Y 的子串,否则个不等式不成立。那么,什么时候等号成立呢?一个充分的条件是,或者 X 不是 Y 的前缀,或者 Y 是 S 的后缀。注意,这个条件只是充分的,而非必要条件。基于这个性质和这个充分条件,就可以设计出一个线性时间复杂度的算法了。
1. 把当前中心位置指针 p 指向第一个可能的中心,即 p :=1
2. 只要 1 <= p <= 2n+1,执行下面循环
a) 以 p 为中心,向两边扩展,直到找到以 p 为中心的最长回文,假设其长度为 k
b) Len[p] := k
c) 利用上述的性质和找到的最长回文,计算 Len[p+1], Len[p+2],... 的值,直到当前已有的信息不足以继续确定某个 Len[p+h] 的值
d) p := p+h
3. 返回 Len 中最大的值及其下标(即中心位置)
这个算法是 O(n) 时间复杂度的,虽然现在似乎不是那么明显,但看了下面更为详尽的伪代码,就很清楚了。
- p := 1
- i := 1
- LP_len := 1 // the length of LP found so far
- LP_center := 1 // the center of LP found so far
- while p <= 2n+1 do
- j := p-i // the pointer extending to left
- // below search the LP centered at p
- while j >= 1 and S[i]=S[j] do
- i := i+1
- j := j-1
- end while
- /* set the length of LP centered at p */
- Len[p] := 2*i - p - 1
- /* track the LP found so far */
- if Len[p] > LP_len then
- LP_len := Len[p]
- LP_center := p
- end if
- /* use the property discussed above to compute values of other slots of Len as possible as we can */
- current_start := j + 1 // the start position of LP centered at p
- p := p + 1 // the next slot of Len to consider
- q := p - 2 // the center of dual of LP centered at p
- while q >= 1 and p <= 2n+1 do
- q_start := (q-Len[q]+1) / 2
- if q_start > current_start or i > n then
- Len[p] := Len[q]
- p := p+1
- q := q-1
- else
- break
- end if
- end while
- end while
- return the pair (LP_len,LP_center)
在上述伪代码中,可以看出,在内部的两个 while 中,要么递增 i 的值( S 中下一个待访问的元素的下标),要么递增 p (下一个考虑的可能中心),而每个递增及其附加操作的复杂度都为 O(1),因此,总的时间复杂度为 O(n)。值得指出的时,Len 数组记录每个中心的最长回文长度,从而该算法实际上求出所有的最大回文子串,而不仅仅是最长的那个。上述的伪代码是为了方便理解而写的,具体实现的代码可能比这个伪代码还要简单,例如原文给出的Python代码。