算法基础提升——KMP，Manacher算法（C++）

一、KMP算法：快速模式匹配算法

参考：KMP 算法详解 - 知乎

注意：

• 1.最好使用字符数组，string类型太慢！！！！
• 2.最好使用scanf输入，cin太慢！！！
• 3.strlen函数在cstring头文件中，注意！！ 

可参考：KMP模板

#include<iostream>
#include<cstdio>
#include<algorithm> 
#include<cmath>
#include<stack>
#include<string>
#include<vector>

using namespace std;

void get_next(int* next, string s2)
{
	int t1 = 0, t2 = -1;
	next[0] = -1;
	while (t1 < s2.length())  //t1指向前缀的最后一项
	{
		if (t2 == -1 || s2[t1] == s2[t2])
		{
			next[t1 + 1] = t2 + 1;
			t1++, t2++;
		}
		else 
		{
			t2 = next[t2];
		}
	}
}

bool kmp1(int* next, string s1, string s2)//判断模式串在字符串中是否出现
{
	int t1 = 0, t2 = 0;
	while (t1 < s1.length() && t2 < s2.length())
	{
		if (t2 == -1 || s1[t1] == s2[t2])
		{
			t1++, t2++;
		}
		else
		{
			t2 = next[t2];
		}
	}
	if (t2 == s2.length()) return true;
	else return false;
}

int kmp2(int* next, string s1, string s2)//求模式串在字符串中出现的次数
{
	int t1 = 0, t2 = 0;
	int times = 0;
	while (t1 < s1.length())
	{
		if (t2 == -1 || s1[t1] == s2[t2])
		{
			t1++, t2++;
		}
		else
		{
			t2 = next[t2];
		}
		if (t2 == s2.length())//匹配成功
		{
			times++;
			t2 = next[t2];
		}
	}
	return times;
}

vector<int> kmp3(int* next, string s1, string s2)//求模式串在字符串中出现的所有位置
{
	int t1 = 0, t2 = 0;
	vector<int> ans;
	while (t1 < s1.length())
	{
		if (t2 == -1 || s1[t1] == s2[t2])
		{
			t1++, t2++;
		}
		else
		{
			t2 = next[t2];
		}
		if (t2 == s2.length())//匹配成功
		{
			ans.push_back(t1 + 1 - s2.length());
			t2 = next[t2];
		}
	}
	return ans;
}

int main()
{
	string s1, s2;
	cin >> s1 >> s2;
	int* next = new int(s2.length() + 5);
	get_next(next, s2);
	vector<int> res = kmp3(next, s1, s2);
	for (int i = 0; i < res.size(); i++)
	{
		cout << res[i] << endl;
	}
	for (int i = 1; i <= s2.length(); i++)
	{
		cout << next[i] << " ";
	}
}

二、Manacher算法：求解最长回文子串

2.1 经典解法

在每个字符间插入一个额外字符（字符可以和原字符串中的字符一样），使得奇数长度的子串和偶数长度的子串都能被表现出来。

例如 level：表现为# l # e # v # e # l #

然后遍历每个字符，以该字符为轴向两侧扩散，得到最长回文字串的长度。

• # ：1（只有自己是回文串）
• l ：3 （# l #）
• # ：1（只有自己是回文串）
• e ：3 （# e #）
• # ：1（只有自己是回文串）
• v ：11 （# l # e # v # e # l #）
• # ：1（只有自己是回文串）
• e ：3 （# e #）
• # ：1（只有自己是回文串）
• l ：3 （# l #）
• # ：1（只有自己是回文串）

所以可以计算得到：最长回文字串长度为 11/2 = 5.

经典解法的时间复杂度为 。

最差情况是当字符串全为某一个字符时，每次遍历都需要到达边界。

---

2.2 优化解法

以上面的例子来说明，当以v为轴时，回文半径为5，回文直径为11；当以e为轴时，回文半径为1，回文直径为3。现在需要使用一个数组将所有字符的回文半径记录下来。

此外还需要两个变量R和c，R用于跟踪回文子串扩散范围的右边界，c用于记录扩散范围的中点（轴）。

接下来字符串指针 i，回文子串右边界R，回文子串左边界L，最长回文子串中点c 存在以下可能的关系：

1.  指针 i 在R的右边：没有任何先验信息，直接暴力扩散找回文字串。
2.  指针 i 在R的左边，并且 i 关于 c 的对称点 j 的回文区域的左边界在L的右边：不需要扩散，结果已知（通过对称点 j 确定）。
3.  指针 i 在R的左边，并且 i 关于 c 的对称点 j 的回文区域的左边界在L的左边：不需要扩散，结果已知。
4.  指针 i 在R的左边，并且 i 关于 c 的对称点 j 的回文区域的左边界就是L：一段区域已知，往后继续扩散。

2.3 代码实现

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdlib>
using namespace std;

char* ManacherString(char str[])
{
	int n = strlen(str) * 2 + 1;
	char* res = new char[n];
	int index = 0;
	for (int i = 0; i != n; i++)
		res[i] = (i & 1) == 0 ? '#' : str[index++];
	return res;
}

int maxLcpsLength(char s[])
{
	char* str = ManacherString(s);//1221 -> #1#2#2#1#
	int* pArr = new int[strlen(str)];//回文半径数组/至少不用验证的区域
	int C = -1; //中心位置
	int R = -1; //回文右边界再往右一个位置
	int Max = -999;
	for (int i = 0; i != strlen(str); i++)//每个位置求回文半径
	{
		//i在R外，不用验，至少不用验的半径为1
		//i'的回文半径超过L或者未超过L，结果都已知，只有R-i不用验
		//i'的回文半径压线，至少pArr[2 * C - i]==R-i不用验
		pArr[i] = R > i ? min(pArr[2 * C - i], R - i) : 1;
		while (i + pArr[i] < strlen(str) && i - pArr[i] > -1)
		{
			if (str[i + pArr[i]] == str[i - pArr[i]])
				pArr[i]++;
			else
				break;
		}//给一个统一往外扩的逻辑，若不需要扩，直接就会break
		if (i + pArr[i] > R)
		{
			R = i + pArr[i];
			C = i;
		}
		Max = max(Max, pArr[i]);
	}
	return Max - 1;
}

int main()
{
	char s[] = "LEVELAL";
	cout << maxLcpsLength(s);
}

时间复杂度为 .