POJ3974 回文串。EXKMP模板和马拉车算法模板

最新推荐文章于 2021-02-19 16:21:14 发布
原创 最新推荐文章于 2021-02-19 16:21:14 发布 · 569 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种利用KMP算法扩展版本来寻找字符串中最长回文子串的方法，通过分治策略实现，虽然时间复杂度较高，但提供了清晰的实现思路和代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题目就是求一个串的最长回文子串，


马拉车算法就不介绍了。。我博客里曾经有过……而且我自己倒是理解透彻不搞了。。


这次是KMP求最长回文子串。


扩展KMP。


求最长回文子串与最长重复子串。

长沙雅礼中学 何林


记录一篇论文叫……


然后就行了……看完就发现分治很神奇。

然后……程序超级慢，毕竟比马拉车多个log。跑了10秒，别人1秒内……多个log太慢了


顺便，获得扩展KMP模板


//得到扩展KMP的next数组。next[i]，T从i开始的串，和pattern的前缀公共长度
//一般对不求extend[i]的数组进行使用。
template<typename T>
void get_extand_next(T pattern[], int lenP, int next[])
{
	int a(0);
	next[0] = lenP;
	for (; a != lenP && pattern[a] == pattern[a + 1]; ++ a);
	next[1] = a;
	a = 1;
	for (int k = 2; k < lenP; ++ k)
	{
		int p = a + next[a] - 1, L = next[k - a];
		//p是最远匹配下标，L是当前串
		if (k-1+L >= p)
		{
			int j = (p - k + 1) > 0 ? p - k + 1 : 0;
			while (k + j < lenP && pattern[k + j] == pattern[j])	j++;
			next[k] = j;
			a = k;
		}
		else next[k] = L;
	}
}


template<typename T>
void get_extend(T text[], int lenT, T pattern[], int lenP, int next[], int extend[], bool flag = 0)//flag表示是否已经得到next数组了,0表示否
//extend[i]表示text[i..lenT-1]和pattern[0..lenP-1]串的公共前缀
{
	if (!flag)	get_extand_next(pattern, lenP, next);
	int a = 0;
	int len = min(lenT, lenP);//两个串取短
	while (a < len && text[a] == pattern[a])	a++;
	extend[0] = a;
	a = 0;
	for (int k = 1; k != lenT; k ++ )
	{
		int p = a + extend[a] - 1, L = next[k - a];
		if (k - 1 + L >= p)
		{
			int j = (p - k + 1) > 0 ? p - k + 1 : 0;
			while (k + j < lenT && j < lenP && text[k + j] == pattern[j])	j++;
			extend[k] = j;
			a = k;
		}
		else extend[k] = L;
	}
}

ac code 

/*
#include <bits/stdc++.h>
#include <ext/pb_ds/priority_queue.hpp>
#include <tr1/unordered_map>
#include <ctime>
using std::tr1::unordered_map;
*/

#include <iostream>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cstdio>
#include <map>
using namespace std;

/*
   using std::sort;
   using std::bitset;
   using std::max;
   using std::cout;
   using std::stack;
   using std::cin;
   using std::endl;
   using std::swap;
   using std::pair;
   using std::vector;
   using std::set;
   using std::map;
   using std::multiset;
   using std::queue;
   using std::greater;
   using std::string;
   using std::priority_queue;
   using std::max_element;
   using std::min_element;

   using __gnu_pbds::pairing_heap_tag;
   __gnu_pbds::priority_queue<int, greater<int>, pairing_heap_tag> heap;
#define Hash unordered_map
*/
#define pr(x) cout<<#x<<" = "<<x<<" "
#define prln(x)    cout<<#x<<" = "<<x<<endl

#define lson o*2, L, M
#define rson o*2+1, M + 1,R

//const int maxn = 210000;
const int maxn = 1000100;





//得到扩展KMP的next数组。next[i]，T从i开始的串，和pattern的前缀公共长度
//一般对不求extend[i]的数组进行使用。
template<typename T>
void get_extand_next(T pattern[], int lenP, int next[])
{
	int a(0);
	next[0] = lenP;
	for (; a != lenP && pattern[a] == pattern[a + 1]; ++ a);
	next[1] = a;
	a = 1;
	for (int k = 2; k < lenP; ++ k)
	{
		int p = a + next[a] - 1, L = next[k - a];
		//p是最远匹配下标，L是当前串
		if (k-1+L >= p)
		{
			int j = (p - k + 1) > 0 ? p - k + 1 : 0;
			while (k + j < lenP && pattern[k + j] == pattern[j])	j++;
			next[k] = j;
			a = k;
		}
		else next[k] = L;
	}
}


template<typename T>
void get_extend(T text[], int lenT, T pattern[], int lenP, int next[], int extend[], bool flag = 0)//flag表示是否已经得到next数组了,0表示否
//extend[i]表示text[i..lenT-1]和pattern[0..lenP-1]串的公共前缀
{
	if (!flag)	get_extand_next(pattern, lenP, next);
	int a = 0;
	int len = min(lenT, lenP);//两个串取短
	while (a < len && text[a] == pattern[a])	a++;
	extend[0] = a;
	a = 0;
	for (int k = 1; k != lenT; k ++ )
	{
		int p = a + extend[a] - 1, L = next[k - a];
		if (k - 1 + L >= p)
		{
			int j = (p - k + 1) > 0 ? p - k + 1 : 0;
			while (k + j < lenT && j < lenP && text[k + j] == pattern[j])	j++;
			extend[k] = j;
			a = k;
		}
		else extend[k] = L;
	}
}

char input[maxn];
int ans;
int suf_left[maxn], suf_right[maxn];
int nxt[maxn], extend[maxn];
char pattern[maxn], text[maxn];

void cal(char s[], int len, int M)//分界线为M-1和M之间
{
	int lenP = len - M;
	int lenT = M;
	//for (int i = 0; i != len; ++ i)	cout<<s[i];cout<<endl;
	//先求出左边串为母串，和左边串的逆为子串的EXKMP
	for (int i = 0; i < M; ++ i)	text[i] = s[i];			//text[i] 为s[0..M-1]
	for (int i = 0; i < M; ++ i)	pattern[i] = s[M - i - 1];	//pattern为s[0..M-1]的逆
	get_extend(text, lenT, pattern, lenP, nxt, extend);	
	for (int i = 0; i < M; ++ i)	suf_left[i] = extend[i];
	//suf_left[i]表示,s[i]为起点往右，和s[M-1]为起点往左，有多少个相同的串

	for (int i = 0; i < M; ++ i)	text[i] = s[M - i - 1];		//text[i]为s[0..M-1]的逆
	for (int i = M; i < len; ++ i)	pattern[i - M] = s[i];

	get_extend(text, lenT, pattern, lenP, nxt, extend);
	for (int i = 0; i < M; ++ i)	suf_right[i] = extend[M - 1 - i];
	for (int i = 1; i < M; ++ i)
	{
		if (suf_left[i] * 2 >=  M - i)//存在
		{
			int tmp = M - i + suf_right[i-1] * 2;
			if (tmp > ans)	ans = tmp;
		}
	}
	int tmp = suf_right[M - 1] * 2;
	if (tmp > ans)	ans = tmp;
}

void solve(char s[], int len)
{
	if (len == 1)
	{
		if (ans < 1)	ans = 1;	//一个元素答案一定为1
		return;
	}
	int M = len / 2;

	solve(s, M);		//s[0]...s[M-1]一共 M个元素 
	solve(s + M, len - M);	//s[M]...s[len - 1] 一共len-M个元素
	cal(s, len, M);
	for (int i = 0; i < len/2; ++ i)	swap(s[i], s[len-i-1]);
	if (len%2==1)	M++;
	cal(s, len, M);
	for (int i = 0; i < len/2; ++ i)	swap(s[i], s[len-i-1]);
}

int main()
{
	int T=0;
	while (~scanf("%s", input))
	{
		if (input[0]=='E')	break;
		int len = strlen(input);
		ans = 1;
		solve(input, len);
		printf("Case %d: ", ++T);
		printf("%d\n", ans);
	}

	return 0;
}



马拉车模板：

//获得manacher算法数组
//给定一个text模板串，下标从0开始。长度为len，输出一个malache数组。同时需要提供一个运算辅助数组str，其类型与text相同
//算法流程：首先给字符首插入未出现的字符，第奇数个字符开始插入#等相同的，并且原字符串没有出现的字符。
//然后在第偶数个位置，按顺序插入原串。比如abbacabba会变为^#a#b#b#a#c#a#b#b#a* 这样的串，首尾都是未出现的串。这样是为了程序避免越界，为了程序好写。
//然后会返回一个manacher数组，表示对于从^#a#b#b#a#c#a#b#b#a*这样的字符串中，每个下标为中心，向左右扩展，能得到的最长回文串的长度。
//实质上，是在原串的(pos-malache[pos]+2)/2-1为左端点，长度为malache[pos]-1的回文串

#include <typeinfo>
template<typename T>
void manacher(T text[], int len, int malache[], T str[])  
{  
	T inf, space;
	if (typeid(T).name() == typeid(char).name())
	{
		inf= -128;
		space = 2 - 127;
	}
	if (typeid(T).name() == typeid(int).name())
	{
		inf= - 0x3f3f3f3f;
		space = 2 -0x3f3f3f3f;
	}
	int l = 0;
	str[l++] = inf;
	str[l++] = space;
	for (int i = 0; i < len; ++ i)
	{
		str[l++] = text[i];
		str[l++] = space;
	}
	str[l] = inf + 1;
	int mx=0, id=0;//mx:最远匹配距离,id:最远距离对应的坐标的下标
	for (int i = 0; i < l; ++ i)
	{
		malache[i] = mx > i ? min(malache[2 * id - i], mx - i) : 1;
		while (str[i + malache[i]] == str[i - malache[i]])	malache[i] ++ ;
		if (i + malache[i] > mx)
		{
			mx = i + malache[i];
			id = i;
		}
	}
	   
}

ac code 

/*
#include <bits/stdc++.h>
#include <ext/pb_ds/priority_queue.hpp>
#include <tr1/unordered_map>
#include <ctime>
using std::tr1::unordered_map;
*/

#include <iostream>
#include <cstring>
#include <queue>
#include <algorithm>
#include <cstdio>
#include <map>
using namespace std;

/*
   using std::sort;
   using std::bitset;
   using std::max;
   using std::cout;
   using std::stack;
   using std::cin;
   using std::endl;
   using std::swap;
   using std::pair;
   using std::vector;
   using std::set;
   using std::map;
   using std::multiset;
   using std::queue;
   using std::greater;
   using std::string;
   using std::priority_queue;
   using std::max_element;
   using std::min_element;

   using __gnu_pbds::pairing_heap_tag;
   __gnu_pbds::priority_queue<int, greater<int>, pairing_heap_tag> heap;
#define Hash unordered_map
*/
#define pr(x) cout<<#x<<" = "<<x<<" "
#define prln(x)    cout<<#x<<" = "<<x<<endl

#define lson o*2, L, M
#define rson o*2+1, M + 1,R

//const int maxn = 210000;
const int maxn = 1000100;

//对于text[]，返回一个out[],out[i]，表示从i开始，可以向右多远是合法的




#include <typeinfo>
	template<typename T>
void manacher(T text[], int len, int malache[], T str[])  
{  
	T inf, space;
	if (typeid(T).name() == typeid(char).name())
	{
		inf= -128;
		space = 2 - 127;
	}
	if (typeid(T).name() == typeid(int).name())
	{
		inf= - 0x3f3f3f3f;
		space = 2 -0x3f3f3f3f;
	}
	int l = 0;
	str[l++] = inf;
	str[l++] = space;
	for (int i = 0; i < len; ++ i)
	{
		str[l++] = text[i];
		str[l++] = space;
	}
	str[l] = inf + 1;
	int mx=0, id=0;//mx:最远匹配距离,id:最远距离对应的坐标的下标
	for (int i = 0; i < l; ++ i)
	{
		malache[i] = mx > i ? min(malache[2 * id - i], mx - i) : 1;
		while (str[i + malache[i]] == str[i - malache[i]])	malache[i] ++ ;
		if (i + malache[i] > mx)
		{
			mx = i + malache[i];
			id = i;
		}
	}
	/*
	   for (int i = 0; i <l;++i)
	   cout<<i<<" ";cout<<endl;
	   for (int i = 0; i <l;++i)
	   cout<<str[i]<<" ";cout<<endl;
	   for (int i = 0; i <l;++i)
	   cout<<malache[i]<<" ";cout<<endl;
	   */
	   
}

char flag[10],input[200000 + 200];
int malache[200000 + 200];
char str[200000 + 200];

int main()
{
	while (scanf(" %s %s ", flag, input) == 2)
	{
		char ch = flag[0];
		int len = strlen(input);
		for (int i = 0; i != len; ++ i)
		{
			input[i] = (input[i]-ch+26)%26 + 'a';
		}
		manacher(input, len, malache, str);
		int pos=0, ans=0;
		for (int i = 0; i < 2 * len + 2; i ++)
		{
			if (malache[i]>ans)
			{
				ans = malache[i];
				pos = i;
			}
		}
		ans--;
		if (ans==1)
			printf("No solution!\n");
		else
		{
			if (pos%2==0)
			{
				//如果是偶数，则为pos/2-1为中点
				//pos-malache[pos]+1为起点
				//起点为 (pos-malache[pos]+1)/2-1为起点，长为malache[pos]-1
				printf("%d %d\n", (pos-malache[pos]+2)/2-1, ans);
			}
			else
			{
				//如果是奇数，则说明为aa或者baab这样的回文串
				//(pos-malache[pos])/2为起点，长度为malache[pos]-1
				printf("%d %d\n", (pos-malache[pos]+2)/2-1, ans);
			}
			for (int i = (pos-malache[pos])/2; i <= (pos-malache[pos])/2 + ans - 1; ++ i)
				printf("%c", input[i]);
			printf("\n");
		}
	}
}


poj3974 manacher算法,最大回文子串
.
05-22 5万+
Sample Inputabcbabcbabcba abacacbaaaab ENDSample OutputCase 1: 13 Case 2: 6就是裸的求最大回文字串//$#a#a#a#b# #include&lt;cstdio&gt; #include&lt;iostream&gt; #include&lt;cstring&gt; using namespace std; const in...
KMP、马拉车、滑动窗口、图、并查集
weixin_45017459的博客
08-29 471
1.KMP算法 参考博客 问题描述：给定一个主串（以 S 代替）和模式串（以 P 代替），要求找出 P 在 S 中出现的位置，此即串的模式匹配问题。java中的String的indexOf方法可以直接返回位置，但是它的方法基本是基于KMP算法的。 如果用传统的暴力循环，时间效率肯定非常慢，所以我们可以使用KMP算法 算法流程： （1） [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-G0aBuPXp-1630226701641)(KMP、马拉车、滑动窗口、图、并查集.asset
POJ3974
weixin_30371875的博客
03-28 153
/* 最长回文子串算法 manacher算法 O(n)线性算法 当然也使用扩展的KMP算法 O(nlogn) */ #include <cstdio> #include <cstdlib> #include <iostream> #include <cmath> #include <algorithm> ...
马拉车算法模板
spnooyseed的博客
03-20 662
大佬博客 马拉车用于解决最长回文子串问题，重点是子串，而不是子序列，想了解最长回文子序列的可以看下这篇博客传送门。对于这种问题，当然最简单粗暴的方法就是暴力求解，但太暴力也不好，毕竟会TLE。所以对于求最长回文子串的问题有一种神奇的算法——马拉车算法，神奇就神奇在时间复杂度为O(n)。 我先说一下大概思路，就是用一个Len[i]数组去存第i个位置到mx位置的长度，然后用id记录上一次操作的位置，m...
ACM的常用算法模板.pdf
最新发布
09-22
Manacher算法用于解决字符串中的最长回文子串问题，该算法通过对称性和边界扩展的方式，将时间复杂度降低到O(n)。 AC自动机是一种用于多模式串匹配的算法，它构建了一棵基于模式串的自动机，能够高效地在一段文本中...
poj2488.rar_poj24_poj2488_方向模板法
09-14
标题中的“poj2488.rar_poj24_poj2488_方向模板法”指的是一个解决编程竞赛问题POJ2488的压缩文件，其中可能包含了解决该问题的代码示例。POJ是Programming Online Judge的缩写，是一个在线的编程竞赛平台，参与者...
POJ编程题代码模板及算法分析
POJ是一个用于在线编程练习和竞赛的平台，它提供了大量编程题目供用户挑战，涵盖了从基础算法到复杂问题的各个难度级别，是编程学习者和算法竞赛选手常用的实践工具之一。 描述中的“自己写的，里面有运行时间和...
POJ - 3974 Palindrome 最长的回文子串 3种不同的方法 字符串hash/Manacher算法
深海沧澜的博客
07-30 1224
Andy the smart computer science student was attending an algorithms class when the professor asked the students a simple question, "Can you propose an efficient algorithm to find the length of the lar...
Manacher's Algorithm 马拉车算法 模板
一条咸鱼
02-19 684
#include &lt;vector&gt; #include &lt;iostream&gt; #include &lt;string&gt; using namespace std; string Manacher(string s) { // Insert '#' string t = "$#"; for (int i = 0; i &lt; s.size()...
马拉车算法(Manacher's Algorithm) //模板
Rshs
03-10 391
manacher算法可以在O(n)时间内求出一个字符串里每一个位置的最长回文串的长度。 https://www.bilibili.com/video/av4829276 跟着上面的视频学两遍就会了。 直接上模板题（manacher模板） #include<bits/stdc++.h> using namespace std; #define LL long long...
POJ-3974
qq_41071646的博客
04-04 325
这道题整整困了我好久好久 一直在研究那个算法  Manacher ，这个算法其实 很厉害 能将  回文串直接搞成线性的 所以我个人感觉  可以看看  至于算法思想  网上的大牛写的都很精髓 我这个小菜虾就不再 说了 直接上代码  如果大家对 这个算法有所了了解 其实这个代码真的很简单 点击打开链接#include&lt;iostream&gt; #include&lt;cmath&gt; #inc...
【字符串】马拉车算法模板
CAIBI WORID
08-16 303
备份链接。。。。。 我自己理解还是等熟练了再发吧。。。。 https://www.cnblogs.com/grandyang/p/4475985.html https://blog.youkuaiyun.com/the_star_is_at/article/details/53354958
马拉车算法板子
lt的博客
02-28 378
#include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;iostream&gt; using namespace std; const int maxn=1e6+5; char s[maxn*2],str[maxn*2]; int Len[maxn*2],len; void getstr(){ int k=0; str...
POJ3974 字符串哈希+二分
weixin_30892037的博客
08-06 204
题目：http://poj.org/problem?id=3974 本来是想练习一下字符串哈希算法的，没想到改了好久的二分，23333。 求字符串中的最长回文字串以前我一直用的dp，当然这道题用dp会T。用哈希+二分可以达到O(NlogN)的时间复杂度。 首先进行正反两次字符串哈希。哈希方法 然后分长度为奇数或偶数两种情况，对于每一个位置i，二分它向一个方向可以延伸的长度，判断使...
HDU 3068 - 马拉车(manacher)算法模板题
shamansi99的博客
02-19 435
马拉车(manacher)算法可以在O(n)时间内求出最长回文子串或回文子串的个数。 马拉车一开始还是比较晦涩难懂的，这里推荐两篇文章，可以帮助了解马拉车算法的思想： 漫画：如何找到字符串中的最长回文子串？ 一文让你彻底明白马拉车算法 第一篇使用了漫画讲解，相对第二篇文章更容易理解马拉车算法的思想，但代码实现上不如第二篇简洁。故推荐先阅读第一篇，要实现代码时再参照第二篇。 #include<algorithm> #include<cstdio> #include<i
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值