最长回文子串 C++ 动规入门

问题描述：
给定一个字符串S,求出S的最长回文子串的长度（这里回文即：顺着和反着都相同，在下的粗鄙解释）
样例输入：
PATZJUJZTACCBCC
样例输出：
9
样例解释：
最长回文子串为ATZJUJZTA

暴力枚举 ：

直接枚举所有端点i，j判断【i，j】是否为回文序列
枚举端点O(2^N),判断回文O(N)
时间复杂度为O（n^3）
代码示例如下：

//暴力枚举 
#include<iostream>
#include<cstring>
using namespace std;
bool IsPalin(string a,int i,int j){//判断是否回文 
	while(i<=j){//两边同时往中间靠近判断是否回文 
		if(a[i]!=a[j]){
			return 0;
		}
		i++;j--;
	}
	return 1;//是回文返回1 
}

int main(){
	string a;
	cin>>a; 
	int max=0;
	for(int i=0;i<a.length();i++){//枚举所有端点 
		for(int j=a.length();j>=i;j--){//注意这里的判断条件 
			if( IsPalin(a,i,j)==1 && max<j-i+1 ){
				max=j-i+1;//刷新最大值 
			}
		}
	}
	cout<<max;
	return 0;
} 

我的一些想法

由于回文序列关于中间对称的特性，以中间位置出发判断判断基于该位置为中心的回文序列的长度。
当然这里有奇偶长度的区分，我采用每次+0.5的方法并分类讨论（后来得知如果为偶数长度情况可以在中心添加一个任意字符来计算）
时间复杂度为O(n^2)
代码示意如下：

//一些优化 
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int GetNum(string a,float i){
	int num=0,temp=i/0.5;//注意这里的类型转换 
	if(temp%2==0){//奇数个情况
		num=1;   	        //下方的判断条件注意 
		for(int j=i+1,k=i-1; k>=0&&j<a.length()&&(a[j]==a[k]) ; j++,k--){
			num+=2;  
		}
	}
	else{//偶数个情况 			  //下方的判断条件注意
		for(int j=i+0.5,k=i-0.5; k>=0&&j<a.length()&&(a[j]==a[k]) ; j++,k--){
			num+=2;
		}
	}
	return num;
}

int main(){
	string a;
	cin>>a;
	int max1=0;
	for(float i=0.5 ; i<=a.length()-1 ; i=i+0.5){
		max1=max(max1,GetNum(a,i));//刷新最大值 
	}
	cout<<max1;
	return 0;
}

一种递归写法

暴力枚举的时间浪费：中间字串是否为回文序列的多次反复判断
状态转移方程如下：

接下来是边界情况的初始化：自然是长度为1，和长度为2 的两种情况作为边界
接下来解决如何保证dp[i+1][j+1] 在dp[i][j] 之前就已经计算过了的问题：
以长度作为外层循环的变量，计算好一个小的长度的所有情况后在计算长度更大的情况；
我的代码如下：

//动规版本 
#include<iostream>
#include<cstring>
using namespace std;

int main(){
	string a;
	cin>>a;
	int b=a.length(),max=1;//以max不断刷新最大值 
	int dp[b][b]; 
	for(int i=0;i<b;i++){
		for(int j=i;j<=i+1;j++){
			if(i==j){//初始化边界情况  长度为1时 
				dp[i][j]=1;
			} 
			if(j-i==1&&a[i]==a[j]){//长度为2时 
				dp[i][j]=2;
				max=2; 
			}
		}
	}
	for(int i=2;i<b;i++){
		for(int j=0;j+i<b;j++){
			if(a[j]==a[j+i]&&dp[j+1][j+i-1]!=0){
				dp[j][j+i]=dp[j+1][j+i-1]+2;//状态转移方程 
				(max>=dp[j][j+i])? max=max : max=dp[j][j+i];//刷新max 
			}
			else{
				dp[j][j+i]=0;//状态转移方程 
			}
		}
	}
	cout<<max;
	return 0;
}				

此外关于回文序列问题：
可以采用二分+hash的做法将复杂度将为O(nlogn)
还可以用manacher法，复杂度为O（n）
部分内容选自《算法笔记》

由于作者自身能力限制，十有八九会有错，敬请指正，谢。