最长回文子串的问题描述：给出一个字符串S，求S的最长回文子串的长度。

针对这个问题，先看暴力解法：枚举子串的两个端点i和j，判断在[i,j]区间内的子串是否回文。从复杂度上来看，枚举端点需要，判断回文需要，因此时间复杂度是。时间复杂度依旧很高。

接下来来看动态规划的方法，使用动态规划可以达到更优的复杂度，而最长回文子串有很多种使用动态规划的方法，这里介绍其中最容易理解的一种。

令dp[i][j]表示S[i]至S[j]所表示的子串是否是回文子串，是则为1，不是为0。这样根据S[i]是否等于S[j]，可以把转移情况分为两类：

（1）若S[i]==S[j]，那么只要S[i+1]至S[j-1]是回文子串，S[i]至S[j]就是回文子串；如果S[i+1]至S[j-1]不是回文子串，则S[i]至S[j]也不是回文子串。

（2）若S[i]!=S[j]，那么S[i]至S[j]一定不是回文子串。

由此可以写出状态转移方程：

 

边界：dp[i][i]=1，dp[i][i+1]=(S[i]==S[i+1])?1:0.

到这里还有一个问题没有解决，那就是如果按照i和j从小到大的顺序来枚举子串的两个端点，然后更新dp[i][j]，会无法保证dp[i+1][j-1]已经计算过，从而无法得到正确的dp[i][j]。

事实上，无论对i和j的枚举顺序如何调整，都无法调和这个矛盾，因此必须想办法寻找新的枚举方式。

根据递推写法从边界出发的原理，注意到边界表示的是长度为1和2的子串，且每次转移时都对子串的长度减1，因此不妨考虑按子串的长度和子串的初始位置进行枚举，即第一遍将长度为3的子串的dp值全部求出，第二遍通过第一遍结果计算出长度为4的子串的dp值…这样就可以避免状态无法转移的问题。

#include<iostream>
#include<cstring>
using namespace std;
const int maxn=1010;
char S[maxn];
int dp[maxn][maxn];
int main(){
	gets(S);
	int len=strlen(S),ans=1;
	memset(dp,0,sizeof(dp));
	for(int i=0;i<len;i++){
		dp[i][i]=1;
		if(i<len-1){
			if(S[i]==S[i+1]){
				dp[i][i+1]=1;
				ans=2;
			}
		}
	}
	for(int L=3;L<=len;L++){
		for(int i=0;i+L-1<len;i++){
			int j=i+L-1;//子串的右端点
			if(S[i]==S[j]&&dp[i+1][j-1]==1){
				dp[i][j]=1;
				ans=L;
			} 
		}
	}
	cout<<ans<<endl;
	return 0;
}