最长回文子串问题

问题描述：给定一个字符串找出最长回文字符串范围，例如abacabac，最长回文子串为abacaba。

1.使用动态规划的思想进行求解，思路是利用子串从短到长进行逐步的动态规划求解，如果一个字符串的子串是回文串，那么就可以存储这个状态，然后从短向长蔓延进行计算：

当i == j 时，肯定是长度为1 的回文串，flag[i][j] = 1

当i+1 == j 时，S[i] == S[j]， 那么flag[i][j] == 1

当flag[i+1][j-1] == 1时，如果S[i] == S[j]， flag[i][j] == 1，（如果子串是回文串，并且首尾相同，那么当前的子串也是回文串）

该方法时间复杂度O(n^2)，空间复杂度O(n^2)，代码如下：

#include "stdafx.h"
#include<iostream>
#include<string>

using namespace std;

string longestpalindrome1(string s)
{
	const int len=s.size();
	int substart=0,maxlen=1;

	int ** flag=new int*[len];
	for(int i=0;i<len;++i)
	{
		flag[i]=new int[len];
		memset(flag[i],0,len*sizeof(int));
	}

	for(int i=0;i<len;++i)
	{
		flag[i][i]=1;
		for(int j=0;j<i;++j)
		{
			if(s[j]==s[i]&&(i-j==1))
			{
				flag[j][i]=1;
				if(maxlen<2)
					{ substart=j; maxlen=2; }
			}
			if(s[j]==s[i]&&flag[j+1][i-1])
			{
				flag[j][i]=1;
				if(maxlen<(i-j+1))
					{ substart=j; maxlen=i-j+1; }
			}

		}
	}
	return s.substr(substart,maxlen);
}

2.可以考虑选取中间点，然后逐步向两边蔓延的策略进行回文串的判断，这种方法相对于动态规划的算法更容易理解，而且空间复杂度会由O(n^2)变为O(1)。代码如下：

string longestpalindrome2(string s)
{
	string substr;
	int len=s.size();
	int substart=0,maxlen=1,j,k;
	for(int i=0;i<len-1;++i)
	{
		j=k=i;//以i为中心扩展
		while(j>=0&&k<len&&s[j]==s[k])
		{
			j--; k++;
		}
		if(maxlen<(k-j-1))
		{
			maxlen=k-j-1;
			substart=j+1;		
		}
		j=i;k=i+1;//以i和i+1扩展
		while(j>=0&&k<len&&s[j]==s[k])
		{
			j--; k++;
		}
		if(maxlen<(k-j-1))
		{
			maxlen=k-j-1;
			substart=j+1;		
		}
	}
	return s.substr(substart,maxlen);
}

3.在网上看到一个O(n)的算法：Manacher，准备学习一下。

（未完待续）