最长回文子串模板

 

O(nlogn) 扩展KMP：

基本的方法是用到了f(n)=2*f(n/2)+O(n) 的分治法， 即复杂度是O(nlogn)

其中n/2是将一个串对半分，算出左边的最长回文子串和右边的最长回文子串，然后单独算跨越中间的回文子串。

跨越的用到了扩展的kmp，我们平常的kmp是能算出从当前位置开始往前能匹配到模板串的最长的长度。 但是我们需要知道从这个位置往后匹配模板串最长能匹配多长，所以这里就是要用扩展kmp了。具体的话由于我不会画图，所以很难解释清楚，所以请百度吧！ 有很多图文并茂的资料。

#include<cstdio>
#include<cstring>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;

const int maxn = 1000000 + 5;
inline int max(int a, int b) { return a > b ? a : b; }
inline int min(int a, int b) { return a < b ? a : b; }
char s[maxn];
int n;
int f[maxn], next_east[maxn], next_west[maxn];
char S[maxn], T[maxn];


inline void swap(char&a, char&b) { a ^= b; b ^= a; a ^= b; }
inline void swap(int &a, int &b) { a ^= b; b ^= a; a ^= b; }


void prefix(char *S, char *T, int lens, int lent,int*next)
{
	int len, L;
	int i, j, k;
	j = 0;
	while (T[j + 1] == T[j] && j < lent) ++j;
	f[1] = j, k = 1;
	for (i = 2; i < lent; ++i) {
		len = k + f[k], L = f[i - k];
		if (len>L + i) f[i] = L;
		else {
			j = len - i>0 ? len - i : 0;
			while (T[i + j] == T[j] && i + j < lent) ++j;
			f[i] = j, k = i;
		}
	}
	j = 0;
	while (S[j] == T[j] && j < lens&&j < lent) ++j;
	next[0] = j, k = 0;
	for (i = 1; i < lens; ++i) {
		len = k + next[k], L = f[i - k];
		if (len>L + i) next[i] = L;
		else {
			j = len - i>0 ? len - i : 0;
			while (S[i + j] == T[j] && i + j < lens&&j < lent)++j;
			next[i] = j, k = i;
		}
	}
}

int ans;
void LP(int l, int m, int r)
{
	int lens = m - l + 1, lent = m - l + 1;
	memcpy(T, s + l, m - l + 1);
	reverse(T, T + lent);
//	prefix(T, T, lent, lent, f);
	memcpy(S, s + l, m - l + 1);
	prefix(S, T, lens, lent, next_east);
//	reverse(next_east, next_east + lens);

	lens = m - l + 1, lent = r - m + 1;
	memcpy(S, T, lens);
	memcpy(T, s + m, r - m + 1);
//	prefix(T, T, lent, lent, f);
	prefix(S, T, lens, lent, next_west);
	reverse(next_west, next_west + lens);

	for (int i = 0; i < lens; ++i) {
		if (next_east[i] + i >= lens - next_east[i]) {
			if (next_west[i] * 2 + lens - i - 2>ans)
				ans = next_west[i] * 2 + (lens - i - 2);
		}
	}
}

void divide_conquer(int l, int r)
{
	if (r - l + 1 <= ans) return;
	else if (r - l + 1 == 2) {
		if (s[l] == s[r]) ans = max(2, ans);
		return;
	}
	int m = (l + r) >> 1;
	LP(l, m, r);
	reverse(s + l, s + r + 1);
	LP(l, m + ((r - l + 1) % 2 == 0), r);
	reverse(s + l, s + r + 1);
	divide_conquer(l, m);
	divide_conquer(m, r);
}

int main()
{
	//GetData(); return 0;
	//freopen("in.txt", "r", stdin);
	int Cas = 0;
	while (scanf("%s", s + 1) == 1) {
		ans = 1;
		if (strcmp(s + 1, "END") == 0) return 0;
		n = strlen(s + 1);
		divide_conquer(1, strlen(s + 1));
		printf("Case %d: %d\n",++Cas, ans);
	//	printf("%d\n", ans);
	}
	return 0;
}

 

 

接下来是O(n)的算法。 这个真心高效啊 ，不管从时间复杂度还是复杂度都是高效的令人发指。

具体的思路也是不好直接用文字说明，请自行百度，也是有很多图文并茂的资料。。。个人认为这个比上面那个扩展kmp的容易理解很多。

#include<cstdio>
#include<string.h>

const int maxn = 1000000 + 5;
int dp[maxn];
char s[maxn], ss[maxn];
inline int max(int a, int b) { return a > b ? a : b; }
inline int min(int a, int b) { return a < b ? a : b; }

int main()
{
	while (scanf("%s", ss) == 1) {
		int n = strlen(ss);
		memset(s, 0, sizeof(s));
		memset(dp, 0, sizeof(dp));
		for (int i = 0; i < n; ++i) {
			s[2*i+2] = ss[i];
			s[2*i+3] = '#';
		}
		s[1] = '#';
		s[0] = '$';
		n = (2 * (n - 1) + 3);
		int j = 1;
		for (int i = 1; i <= n; ++i) {
			if (i <= j + dp[j]) dp[i] = min(dp[2 * j - i], dp[j] + j - i);
			while (s[i + dp[i] + 1] == s[i - dp[i] - 1]) ++dp[i];
			if (dp[i] + i > j + dp[j]) j = i;
		}
		int ans = 1;
		for (int i = 1; i <= n; ++i) {
			if (s[i] == '#') ans = max(ans, (dp[i] + 1) / 2 * 2);
			else ans = max(ans, dp[i] / 2 * 2 + 1);
		}
		printf("%d\n", ans);
	}
}