LeetCode(4) || Longest Palindromic Substring 与 Manacher 线性算法
题记
本文是LeetCode题库的第五题，没想到做这些题的速度会这么慢，工作之余全部耗在这上面了，只怪自己基础差。本文主要介绍使用Manacher线性算法来求解字符串的最长回文子字符串。
题目
Given a string S, find the longest palindromic substring in S. You may assume that the maximum length of S is 1000, and there exists one unique longest palindromic substring.
解题思路
- 题目意思比较简单，假设字符串S最大长度是1000，求出该字符串的最长回文字符串。假设存在唯一的最长回文字符串。
- 回文有两种情况，第一种"aba"，第二种"abba"，如果没有较有效的方法，在后续的求解中这两种情况将大大增加解题难度。Manacher算法使用了一种比较有效的方法。假设字符‘#‘没有出现在S中,将‘#‘依次插入到字符串S中，比如"aba"->"#a#b#a#"，"abba"->"#a#b#b#a#"，这样就巧妙的将两种情况合在一起解决了。
1 public char[] expandString(String s){
2 int len = s.length();
3 char[] cs = new char[len*2+3];
4 for(int i = 0; i < len; i++){
5 cs[2*i+1]=‘#‘;
6 cs[2*i+2]=s.charAt(i);
7 }
8 cs[0]=‘*‘;
9 cs[2*len+1]=‘#‘;
10 cs[2*len+2]=‘?‘;
11 return cs;
12 }
13 public String shrinkString(char[] cs){
14 int len = cs.length;
15 char [] shrinkChars = new char[len];
16 int j=0;
17 for(int i = 0; i < len;i++){
18 if (cs[i] != ‘#‘){
19 shrinkChars[j++] = cs[i];
20 }
21 }
22 return new String(shrinkChars).trim();
23 }
- 解此题最暴力的事情就是使用两个for循环，计算复杂度在O(n2)，我们首先排除这种野蛮的方法，否则做这题就没意义了。
- 我想到的方法是计算复杂度在O(n*log(n))的一种方法，方法大致思路如下：
- 遍历字符串S，假设当前位置为i，将i向两边开始遍历，利用回文关于重点对称的特性来求取回文， while(cs[i+j]==cs[i-j]) j++;
- 这里数组P是存放当前位置的最长回文半径，建下文的Manacher线性算法。
public String longestPalindrome(String s) {
char[] cs = expandString(s);
int len = cs.length;
int [] p = new int[len];
int max = 0;
for(int i = 1; i <len-1 ; i++){
p[i]=1;
while(cs[i+p[i]]==cs[i-p[i]]) p[i]++;
if (p[i] > p[max]){
max = i;
}
}
int lenMax = p[max];
char [] result = new char[2*lenMax-1];
result[lenMax-1] = cs[max];
for(int i = 1 ; i < lenMax ; i++){
result[i+lenMax-1] = cs[max+i];
result[lenMax-1-i] = cs[max+i];
}
return shrinkString(result);
}
- 第二种方法虽然在LeeCode中解出了最大回文字符串，但是在求解过程中由于重复求解还是浪费了很多时间，比如S="abababa"，S是关于S[3]回文的，当遍历S[1]时候，由于对称关系S[5]的一部分回文已经确立了，所以无需再S[4]到S[6]之间就无需再遍历，只需完成映射即可。这就是Manacher线性算法的核心内容，Manacher线性算法最大程度上使用了回文的特性，算法内容在下文中介绍。
Manacher 线性算法
具体的Manacher线性算法详见《最长回文子串（Longest Palindromic Substring）》。
利用一个辅助数组 arr[n]，其中 arr[i] 记录的是以 str[i] 为中心的回文子串长度。当计算 arr[i] 的时候，arr[0...i-1] 是已知并且可被利用的。Manacher 核心在于：用 mx 记录之前计算的最长的回文子串长度所能到达的最后边界，用 id 记录其对应的中心，可以利用回文子串中的回文子串信息。
假设 id 与 mx 已经得出，当计算以 str[i] 为中心回文子串长度时，因为已经可以确定绿色部分已经是回文子串了，所以可以利用以 str[j] 为中心回文子串长度即 arr[j]。在上图的情况下，所以可以从箭头所指出开始比较。还有一种情况：
这种情况下，不能直接利用以 str[j] 为中心回文子串长度即 arr[j]，因为以 id 为中心回文子串长度只计算到了绿色箭头所指之处，所以能力利用的信息是 mx-i，比较 mx-i 之后的字符。
Manacher算法代码如下：
1 public String longestPalindromeOne(String s) {
2
3 char[] cs = expandString(s);
4 int len = cs.length;
5 int [] p = new int[len];
6 int id = 0;
7 int max = 0;
8 for(int i = 1; i <len-1 ; i++){
9 if (i < p[id]+id){
10 p[i]=Math.min(p[id]+id-i, p[2*id-i]);
11 }else{
12 p[i]=1;
13 }
14
15 while(cs[i+p[i]]==cs[i-p[i]]) p[i]++;
16
17 if( p[i]+i> p[id]+id ){
18 id = i;
19 }
20
21 if (p[i] > p[max]){
22 max = i;
23 }
24
25 }
26
27 int lenMax = p[max];
28 char [] result = new char[2*lenMax-1];
29 result[lenMax-1] = cs[max];
30 for(int i = 1 ; i < lenMax ; i++){
31 result[i+lenMax-1] = cs[max+i];
32 result[lenMax-1-i] = cs[max+i];
33 }
34
35 return shrinkString(result);
36 }
关于Manacher算法要补充说明一下几点：
- 为防止在遍历while(cs[i+p[i]]==cs[i-p[i]]) p[i]++;时，需要对字符串进行处理，在字符串S[0]添加字符‘*‘，在字符串末尾S[N+1]添加字符‘?‘，这样房子因为S本身为回文而使得遍历出错。
- 数组p表示字符的回文半径，比如S="#a#b#c#g#c#h" 数组为P="121212141211"，S[7]=g 的 回文半径为p[7]=4
- id表示前一个回文字符串的中心字符的编号，那么p[id]为前一个回文字符的半径。比如当i=8时，前一个回文字符串为"#c#g#c#"，p[id]=4。
- p[i]=Math.min(p[id]+id-i, p[2*id-i]); 的意思就是，如果i位于前一个回文字符串的半径内(即 i < p[id]+id)，i到回文字符的两个最远边界(由于回文字符关于id位置对称，最左边为p[2*id-i]，最右边为p[id]+id-i)的最小距离为Math.min(p[id]+id-i, p[2*id-i])。根据对称关系，如果i到Math.min(p[id]+id-i, p[2*id-i])的元素不需要再进行遍历，只需直接从Math.min(p[id]+id-i, p[2*id-i])开始后续的回文检查while(cs[i+p[i]]==cs[i-p[i]]) p[i]++;。这样做的好处是大大减少了重复步骤，降低计算复杂度。
- 每一个id对应的是一个回文字符串，只要在记录遍历过程中p[id]最大的id即可获取最长的回文字符串。
时间： 2024-10-19 01:18:40