Manacher's Algorithm 马拉车算法（C++）

Manacher’s Algorithm 马拉车算法

什么鬼名字？
参考以下链接，把java代码用c++写了一遍
最长回文字符串算法-Manacher’s Algorithm-马拉车算法

算法介绍

这个马拉车算法Manacher‘s Algorithm是用来查找一个字符串的最长回文子串的线性方法，由一个叫Manacher的人在1975年发明的，这个方法的最大贡献是在于将时间复杂度提升到了线性，这是非常了不起的。对于回文串想必大家都不陌生，就是正读反读都一样的字符串，比如 “bob”, “level”, “noon” 等等，那么如何在一个字符串中找出最长回文子串呢，可以以每一个字符为中心，向两边寻找回文子串，在遍历完整个数组后，就可以找到最长的回文子串。但是这个方法的时间复杂度为O(n*n)，并不是很高效，下面我们来看时间复杂度为O(n)的马拉车算法

思路

首先，我们需要讲输入的字符串 S 进行一下转换得到 T，转换的方法就是通过在每两个字符之间插入一个字符串“#”,你马上就能知道为什么要这么做。

例如 输入字符串 S = “abaaba”, 转换之后得到了 T = “#a#b#a#a#b#a#.

为了找到最长回文字符串，我们的做法是在从T中的第 i 元素开始往字符串的两边进行扩展，例如T[i -d] 到 T[i +d]表示的是以T[i]为中心的回文字符串，你看到这个表示应该就能理解实际上回文字符串的长度是 2 * d。

为了找到最长的回文子串，那么必不可少的就是找出以每个字符为中心的最长回文子串，然后比较之后才能找出最长的。在这里我们使用数组P来保存以T中每个字符为中心的最长回文子串的半径（既长度的一半）。

1. 接着使用上面的例子，
2. T = # a # b # a # a # b # a #
3. P = 0 1 0 3 0 1 6 1 0 3 0 1 0

通过查看数组P，找到其中最大的数字，我们可以马上看出最长的回文字符串是”abaaba”.

马拉车算法就是教你如何巧妙的求出数组P

不知道你是否注意到了我们插入的字符# ,通过插入这个字符，我们可以一次性的处理当输入字符串为奇数或者偶数的情况，而不需要分情况讨论。

不知道你又没有注意一个很重要的事情，那就是观察P中元素，他们是关于中心对称的，不仅仅是这个，在回文串“aba”中，他们在P中对应的数字(1, 3 , 1})也是对称的。这仅仅是一个巧合么？答案可以说是也可以说不是。这种对称的情况仅仅在某种情况下才成立，但是无论如何我们都获得了一个重大的发现。通过这个发现，我们可以减少P中元素的重复计算。

现在让我们来看一个更加复杂的例子,其中包含了一些重叠的回文子串。
S = “babcbabcbaccba”.

上面的图片是从S转换之后得到的T,假设你已经完成了P数组的部分数值的计算，图中的实线表示当前回文串 “abcbabcba”的中心(center C )，两条虚线分别表示以C为中心的回文串的边界。你先需要计算的是 i 的值，图中 i’ 表示的是i 关于 C 对称的点。那么问题来了，怎么计算更有效率的算出P[i] 值。

假设当前 i 的值是 13，我们需要得到 P[13]的值，我们首先看下 i 关于 C对称的 i’ = 9的值。

两条绿色实线覆盖的区域分表表示的是 以 i’ 和 i 为中心的最长回文子串。我们已经知道了 P[i’] = P[9] = 1, 那么非常明显，我们可以推断出 P[i] = P[i’] = 1, 因为回文子串的对称性。(这里稍微解释一下： 因为我们已经知道 a )

正如你在上一段看到的一样，P[i] = P[i’] = 1,这个是由回文子串关于其中心的对称性所决定的。实际上在C之后的三个元素都遵循了这种对称性（既 P[12] = P[10] = 0, P[13] = P[9] =1, P[14] = P[8] = 0 ).

现在我们到了 i = 15 这个点，i 关于 C对称的点是 i’ = 7 ,那么这里 P[15] = P[7] = 7 还会不会成立呢？

很不幸，这个时候如果认为P[15] =7那就错了，如果我们以T[15] 为中心开始两边扩展，那么得到的最长回文子串是”a#b#c#b#a”, 这比我们根据对称性所得到的值 7 要小，那么原因是什么？

在上图中，绿色实线表示的是以C为中心的最长回文子串所覆盖的区域，红色实线表示的是与绿色区域不匹配的部分，左边的红色实线是以i’为中心的最长回文子串所覆盖区域超出绿色实线的部分。右边的红色实线是以i为中心的最长回文子串所覆盖区域超出绿色实线的部分。而绿色的虚线部分则是分别以 i 和 i’ 为中心最长回文子串与 绿色实线部分的重叠部分。

从图中我们可以明显的看出被两条绿色实线所覆盖的区域中，C两边的子串是完全相同的。同时绿色虚线的那部分也是关于中心对称的。但是需要注意的是 P[i’] = 7，此时以T[i’]为中心的最长回文子串超出了以C为中心的最长回文子串的左边界(图中L, 左边红色实线)，正是因为这个原因，这个时候无法再按照回文子串的对称性来处理了。

现在我们知道的是P[i] >= 5 ,为了找出P[i]最终的值，我们只有继续以P[i]为中心向两边扩展进行比较，在这个例子中P[21] 不等于 P[1],那么我们最终推断是P[i] = 5.

那么总结下来就是下面的伪码

if P[ i’ ] ≤ R – i
then P[ i ] ← P[ i’ ]
else P[ i ] ≥ P[ i’ ]. (Which we have to expand past the right edge ® to find P[ i ].

这个表达式是否足够明了，如果你能掌握上面的公式，那么说明你已经知道了这个算法中最精髓也是最难的部分。

接下来的部分就什么时候该去移动当前回文子串的中心C和右边界R的位置，这个相对简单：

如果以i为中心的回文子串的右边界，向右扩展的时候超过了当前的R，那么就将C更新为 i,并且更新R到新的以i为中心的回文子串的右边界。

在每一步中，都存在两种可能，如果P[i’] <= R - i ,我们将P[i]的值设置为P[i]，否则我们会尝试以P[i]为中心并且从 R 开始去扩展回文子串，在扩展的过程中最多执行N步,移动和测试每一个中心(P[i])一共需要耗费N步，那么总的时间复杂度是O(n).

#include <vector>
#include <iostream>
#include <string>

using namespace std;

vector<int> Manacher(string s) {
	// Insert '#'
	string t = "#";
	for (int i = 0; i < s.size(); ++i) {
		t += s[i];
		t += "#";
	}
	// Process t
	int n = t.size(),c = 0, r = 0, j, i1;
	vector<int> p(n, 0);
	for (int i = 0; i < t.size(); i++)
	{
		i1 = 2 * c - i;
		if (i < r) {

			p[i] = (r - i < p[i1]) ? (r - 1) : p[i1];

		}
		else 
		{
			p[i] = 0;
		}

		while ((i + 1 + p[i]) < n && (i - 1 - p[i]) >= 0&& t[i + 1 + p[i]] == t[i - 1 - p[i]] )p[i]++;//向外扩展
			
		if (i + p[i] > r) //更新c，r;
		{
			c = i;
			r = i + p[i];
		}
	}
	return p;
}

int main() {
	string s1;
	cin >> s1;
	vector<int> a = Manacher(s1);
	for (int t = 0; t < a.size(); t++)
		cout << a[t];
	
}