HihoCoder第一周与POJ3974：最长回文字串

这个题目是hihoCoder第一周的题目，自己打算从第一周开始做起，不知道能追上多少，更不知道这一篇写完，下一篇会是什么时候。。。

题意很简单。

输入：

3

abababa

aaaabaa

acacdas

输出：

7

5

3

这种经典题目POJ上也有，忘了是第多少道了。

当时我对于Manacher算法不是很理解，其实现在也感觉恍惚。不知道当我写完的时候会不会大彻大悟。

另外，写这篇总结参考了很多大牛博客上的代码，代码可能有雷同，我的锅。但自己的感想是真实的。

第一种方法，直接暴力：

#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
 
void result (string test)
{
	int count = test.size();
	int start=0,end=count-1,max=0;
	int i,j,loop;
 
	for(i = start; i < end; i++){
		for(j = end; j > start; j--){
			for(loop = (j-i)/2 ; loop >= 0;loop--){
					if(test[i+ loop] == test[j- loop])
					   continue;
					else
					   break;
			}
			if(loop == -1){
				if(j-i+1 > max){
				    max=j-i+1;
				}
 
			}
 
		}
 
	}
	printf("%d\n",max);
}
 
int main()
{
	int count=1;
	while(true)
	{
		string test;
        cin>>test;
        if(test == "END")
         return 1;
        else
        cout<<"Case "<<count++<<":";
		result(test);
 
	}
	return 0;
}

这种方法不难理解，对于一个字符串

记录其开始节点start，结尾节点end。以start为轴，不断去找使其loop为-1，即是回文的end。依次试，start++。记录最大值即可。

这种算法，因为对字符串循环遍历了两遍，所以时间复杂度O(n平方)。

第二种方法，动态规划：

#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
 
void result (string test)
{
	bool testarr[1000][1000] = {false};
	int count = test.size(),max = 0;
 
	for(int i=0;i<count;i++){
 
		testarr[i][i]=true;
 
		if(i+1<count&&test[i]==test[i+1]){
 
			max = 2;
			testarr[i][i+1] = true;
 
		}
	}
	for(int len=3;len<=count;len++)
 
		for(int i=0;i<=count-len;i++){
 
			int j=i+len-1;
			if(testarr[i+1][j-1]&&test[i]==test[j]){
 
				max=len;
				testarr[i][j]=true;
			}
 
		}
	cout<<max<<endl;
}
 
int main()
{
	int count=1;
	while(true)
	{
		string test;
        cin>>test;
        if(test == "END")
         return 1;
        else
        cout<<"Case "<<count++<<":";
		result(test);
 
	}
	return 0;
}

一直以来其实都不是很理解动态规划的具体含义，只知道就那么回事。看动态规划的代码总是一看就懂，但具体使用，除非告诉我这道题是动态规划的题，否则就想不到。举一反三的能力一次也没拥有过。。。以后要加强。

这里的testarr[i][j]如果是true的话，说明这个字符串从i到j是回文，即其长度j-i+1。这个题目动态规划的思想在于，如果我已知testarr[i-1][j-1]是true，那么再判断test[i]与test[j]是否相等，如果相等，即把testarr[i][j]标记为true。

有意思的是，这里的外层循环不是遍历字符串，而是查找对应长度的回文，从长度为3开始，看字符串中是否含有长度为3的回文，内层循环从字符串的位置0开始查找。一次找看看最终能不能找到长度为size的回文，找到其中最大值，记录下来。

我把动态规划思想理解为一个由小变大，滚雪球的过程。在过程中产生一些结果，后面的结果又以前面的结果为基础，得到最终答案。

代码有的时候会有这种感受，写完之后再理思路感觉都没什么亮点，但在写的过程中，遇到的bug也真是煎熬。

第三种方法，Manacher方法：

#include <cstdio>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
 
char str[1000005];
int p[1000005<<1];
char a[1000005<<1];
int min(int a,int b){
	return a>b?b:a;
}
void result(){
	int maxLine=0,ID=1,maxResult=0;
	int n=0,i,len,lentmp;
	lentmp=strlen(str);
	len=lentmp<<1;
 
	for(i=0;i<(1000005<<1);i++){
		p[i]=0;
		a[i]='#';
	}
	for(i=0;i<lentmp;i++){
		a[((i+1)<<1)-1]=str[i];
 
	}
 
	for(i=1;i<len;i++){
 
		if(maxLine >i){
			p[i]=min(p[2*ID-i],maxLine-i);
		}
		else{
			p[i]=1;
		}
 
		while(a[i+p[i]]==a[i-p[i]]){
			p[i]++;
 
		}
		if(p[i]+i>maxLine){
		   maxLine=p[i]+i;
		   ID=i;
		}
		if(p[i]>maxResult){
		   maxResult=p[i];
		}
	}
 
	cout<<maxResult-1<<endl;
}
int main()
{
	int count=1;
	while(true)
	{
        cin>>str;
        if(strcmp(str,"END")==0)
         return 1;
        else
        cout<<"Case "<<count++<<": ";
		result();
	}
	return 0;
}

刚刚介绍的方法都有弊端，前两种方法的弊端在于我遍历一遍字符串只对一个节点记录信息，就是所有我记录的信息都只对一个节点有用，这就导致我不得不对每一个节点都再遍历一遍，导致时间复杂度n的平方。第三种方法的弊端在于我已经知道字符串最大的回文子串撑破天可能也就是其size，那我就从2开始试呗。

而实际上，我可以试试在遍历一次字符串时得到信息的最大值。

这里变量的含义：

P[i]代表以i为中心时能够到达最远的字符。

maxLine实际上就代表已经扫描到的最右边的字符，即maxLine=P[ID]+ID。

ID代表当前使得扫描到最右边字符的那个位置上的字符。

maxResult 就是记录最终的结果值，即找到最大的那个P[i]。

所以，到这里，整个算法最难理解的实际就是这么一段代码：

if(maxLine>i)

{

p[i]=min(p[2*ID-i],maxLine-i);

}

Else

{

p[i]=1;

}

注意，这里并非直接给P[i]盖棺定论，而只是给P[i]赋一个初始值，后面还要有判断，P[i]是否++。这个赋初始值其实也是整个算法的亮点。总结一下就是csdn上的一篇博客的评论挺经典的：

大家可以想象一下，如果P[2*ID-i]这个值很大很大。由于ID的对称性，阻止P[i]初始值的更大的，恰恰就是maxLine-i，因为更远的还没有比对，不知道结果。

而如果maxLine-i这个值很大很大，就是多远的都已经比对完了。那么也因为ID的对称性，P[i]初始值也即P[2*ID-i]。

自己总结的Manacher算法就这么多，我还很菜，还在努力进步，如果有不对的地方，小弟还望各路大牛指点指正。

版权声明：本文为博主原创文章，未经博主允许不得转载。