马拉车算法

 

一。回文字符串可能是奇回文也可能是偶回文，暴力解法需要在每次计算以s[i]为中心的最长回文时都要分两种情况。

如aavaa,bacca，它们的最长回文分别是aavaa和acca。为了简化处理，我们在每一个字符的左右两边都加上特殊字符（肯定不存在于原字符串中的字符），让字符串的最长回文始终变成一个奇回文。#a#a#v#a#a#,#b#a#c#c#a#的最长回文分别是#a#a#v#a#a#和#a#c#c#a#。

二。定义一个与处理后字符串等长的整型数组p,其中p[i]的值代表以s[i]为中心的最长回文的半径，p[i]=1代表以s[i]为中心的最长回文就是s[i]本身。

例如：

i    0 1 2 3 4 5 6 7 8 9 10             i   0 1 2 3 4 5 6 7 8 9 10 

s   # b # a # c # c # a #               s   # a # a # v # a # a #

p   1 2 1 2 1 2 5 2 1 2 1              p   1 2 1 2 1 6 1 2 1 2 1

显然，当找到p中的最大值，就能找到s中的最长回文子串。

三。马拉车算法的核心跟KMP一样，在于利用已经得到的结果去减少计算下一个结果所需要的比较次数。这里的结果就是已经计算过的p[i]，也就是以s[i]为中心，p[i]为半径的左右两边的字符串是具有镜像对称性的。

这里我们定义两个辅助变量id和mx，mx是当前所计算出的回文子串中，能延伸到最右端的位置的下标，id则是该回文子串的中心点位置，也就是说 mx是目前计算出的x+p[x]的最大值，id是得到该最大值的x。

当我们计算图中p[i]，p[j],p[id]肯定是已经计算过了，那么我们可以得出，以i为中心，mx-i为半径的区域和以j为中心 j-mx的对称点 为半径的区域是严格镜像对称的，也就是说图中绿色部分是严格镜像对称的。那么如果p[j]<=mx-i，p[i]=p[j],如果p[j]>mx-i,那么至少有p[i]=mx-i。

		if mx > i {
			//2id-i为j  就是i关于id的对称点
			p[i] = min2Int(mx-i, p[2*id-i]) //关键   （包括在内的，由对称性知）
		} else {
			p[i] = 1
		}
		//log.Println(i, p[i])
		for news[i-p[i]] == news[i+p[i]] { //头尾必不等 不会出界
			p[i]++
		}

四。我们可以看到规律：不论原始回文字符串长度N为奇数还是偶数，那么转化后其肯定含有N+1个#。所以原始回文子串的长度为(p[i]*2-1-1)/2=p[i]-1

五。原始回文子串的起始位置

原始回文子串中心位置为(i-1)/2（偶数则偏左），半径为((p[i]-1-1)/2)（偶数则半径减一对应偶数偏左）

 

func manacher(s string) string {
	//初始化字符串  添加字符#
	news := "#" //加个头
	for _, v := range s {
		news = news + string(v) + "#"
	}
	log.Println(news)
	p := make([]int, len(news), len(news))
	mx := 0 //当前已算出的最大回文的最右边界下标
	id := 0 //当前已算出的最大回文的中心的下标
	l := -1
	index := 0
	for i := 1; i < len(news)-1; i++ {
		if mx > i {
			//2id-i为j  就是i关于id的对称点
			p[i] = min2Int(mx-i, p[2*id-i]) //关键   （由对称性知）
		} else {
			p[i] = 1
		}
		for (i-p[i]) >= 0 && (i+p[i]+1) <= len(news) && news[i-p[i]] == news[i+p[i]] {
			p[i]++
		}
		if p[i]+i > mx {
			mx = p[i] + i
			id = i
		}
		if l < p[i]-1 {
			l = p[i] - 1
			index = i
		}

	}
	//
	//源字符串起始坐标 l为最大回文直径
	start := (index-1)/2 - (l-1)/2
	return s[start : start+l]
}