找到最长回文字符串 - Manacher's Algorithm

记得刚开始学习计算机的时候，除了输出星星就是找到最长回文字符串这样的问题， 开始以为最长回文串问题很简单，但是经过多年的学习再回头看的时候发现，它并不简单，今天就给它解个密。

开始我们先来看一个时间复杂度差的算法。 

1. 时间复杂度为 n^3.    空间复杂度为 1.  这个算法基本上是最简单的了，最好理解的。

/**
* 使用iteration
* 循环三次
* 	 	第一次（最外边循环 ： 从最长的长度开始，循环长度，每次减1
* 		第二次 （中间循环）： 对每个长度，循环最长字符串的起始点，起点从0每次加1
* 		第三次 （最内循环）： 对每个长度每个起点，对左右进行比较，每次左＋1，右－1
*
*
*
*
* */
public static String longestP (String S) {
if (S.length() < 2 || S == null) { return S; }
int length = S.length();
int left = 0;
int right = 0;
while (length >= 0) {

for (int i = 0; i + length - 1 < S.length(); i++) {
left = i;
right = i + length - 1;

while (left < right) {
if (S.charAt(left) == S.charAt(right)) {
left ++;
right --;
continue;
} else {
break;
}
}

if (left >= right) { return S.substring(i, i+ length); }
}

length --;
}

return "";
}

2. Manacher's Algorithm － 时间复杂度为 N ( 应该大于N 小于 N ^ 2)
这个算法需要一个预处理和主要的三个变量。

预处理： 将输入字符串的各个字符使用特殊字符进行 分割，比如 ＃。   e.g.  input: abba 处理: #a#b#b#a#

三个主要变量： 

1. 一个和预处理之后大小一样的 int 数组 rad[] － 用来存储以当前字符为中心的最长子回文字符串的半径。

2. 一个整形变量来存储－ 我们遍历过的所有子回文字符串能触及到的最右边的位置的maxRight。

3. 另一个整形变量来存储 － 2.中maxRight所对应的 子回文字符串的中心点的位置pos。

每次遍历从以当前字符为中心向两头扩展，扩展的半径是多少？

这就是个问题。。。

解决办法， 通过对比 i 和 maxRight， 当i < maxRight 的时候， 判断 maxRight - i 的大小 和  一个点 j ( 这个点是 i 以 pos为对称的  对称点 )的最长回文半径的大小（存储在rad 中). 

使用较小值作为半径， 从当前点开始进行两头扩张。每次扩张成功之后半径＋1。

public static String Manacher (String S) {
if (S.length() < 2 || S == null) { return S; }

//construct new string
//basically, insert one # to the String S,
//make sure each character is surrounded by #
StringBuilder newS = new StringBuilder();
newS.append("#");

int start = 0;
while (start < S.length()) {
newS.append(S.charAt(start));
newS.append("#");

start ++;
}

int [] rad = new int[newS.length()];	//to store the radius of a string with pivot of current node
int maxRight = -1;	//most right we can touch.
int pos = -1;		//the position for which node that can touch the most right.

for (int i = 0; i < newS.length(); i++) {
int r = 1; 	//radius

if (i <= maxRight) {
//since i is less than the max right,
//so we can compare the radius of the node which is symmetric with pos and centered on current node
r = Math.min(rad[2*pos - i], maxRight - i);
}

//extend the string, compare with the i - r(left) and i + r (right)
//if they equal, so that radius ++
while (i - r >= 0 && i + r < newS.length()
&& newS.charAt(i-r) == newS.charAt(i+r)) {
r++;
}

//if i + r -1 is greater than the most right that the most right we can touch.
//we have to update the max right and the position of max right
if (i + r - 1 > maxRight) {
maxRight = i + r - 1;
pos = i;
}

rad[i] = r;
}
int MaxR = 0;
int pivot = 0;
for (int i = 0; i < rad.length; i++) {
if (rad[i] > MaxR) {
MaxR = rad[i];
pivot = i;
}

}
return newS.substring(pivot - MaxR + 1, pivot + MaxR).replace("#", "");
}

有问题欢迎指出。