leetcode——最长回文子串

关于这道题，我的第一想法是针对回文串的特性，对字符串的每个字符（奇数回文串）或者每两个字符（偶数回文串）向两边开始扩展分析。在这个过程中不断发现最新的最长回文串。显然这个算法的复杂度为O(n^2)

class Solution 
{
public:
	string longestPalindrome(string s) 
	{
		//中心扩展法
		int maxlen;
		int prev;
		int next;
		string result;
		maxlen = 0;

		//回文串为奇数时
		for (int i = 0; i < s.size(); i++)
		{
			prev = i;
			next = i;
			while (true)
			{
				prev = prev - 1;
				next = next + 1;
				if (prev < 0 || next > s.size() - 1)
				{
					if ((next - 1) - (prev + 1) + 1 > maxlen)
					{
						maxlen = (next - 1) - (prev + 1) + 1;
						result.assign(s, prev + 1, maxlen);
					}
					break;
				}
				if (s[prev] != s[next])
				{
					if ((next - 1) - (prev + 1) + 1 > maxlen)
					{
						maxlen = (next - 1) - (prev + 1) + 1;
						result.assign(s, prev + 1, maxlen);
					}
					break;
				}
			}
		}

		//回文串为偶数时
		for (int i = 0; i < s.size(); i++)
		{
			prev = i;
			next = i+1;
			if (prev >= 0 && next <= s.size() - 1 && s[prev] == s[next])
			{
				while (true)
				{
					prev = prev - 1;
					next = next + 1;
					if (prev < 0 || next > s.size() - 1)
					{
						if ((next - 1) - (prev + 1) + 1 > maxlen)
						{
							maxlen = (next - 1) - (prev + 1) + 1;
							result.assign(s, prev + 1, maxlen);
						}
						break;
					}
					if (s[prev] != s[next])
					{
						if ((next - 1) - (prev + 1) + 1 > maxlen)
						{
							maxlen = (next - 1) - (prev + 1) + 1;
							result.assign(s, prev + 1, maxlen);
						}
						break;
					}
				}
			}
		}
		return result;
	}
};

====================================================================

第二种方法，使用DP。这个是在网上搜集到的。

回文字符串的子串也是回文，比如P[i,j]（表示以i开始以j结束的子串）是回文字符串，那么P[i+1,j-1]也是回文字符串。这样最长回文子串就能分解成一系列子问题了。这样需要额外的空间O（N^2)，算法复杂度也是O(N^2)。

首先定义状态方程和转移方程：

P[i,j]=0表示子串[i,j]不是回文串。P[i,j]=1表示子串[i,j]是回文串。

P[i,i]=1

P[i,j]｛=P[i+1,j-1],if(s[i]==s[j])

=0 ,if(s[i]!=s[j])

string findLongestPalindrome(string &s)
{
	const int length=s.size();
	int maxlength=0;
	int start;
	bool P[50][50]={false};
	for(int i=0;i<length;i++)//初始化准备
	{
		P[i][i]=true;
		if(i<length-1&&s.at(i)==s.at(i+1))
		{
			P[i][i+1]=true;
			start=i;
			maxlength=2;
		}
	}
	for(int len=3;len<length;len++)//子串长度
		for(int i=0;i<=length-len;i++)//子串起始地址
		{
			int j=i+len-1;//子串结束地址
			if(P[i+1][j-1]&&s.at(i)==s.at(j))
			{
				P[i][j]=true;
				maxlength=len;
				start=i;
			}
		}
	if(maxlength>=2)
		return s.substr(start,maxlength);
	return NULL;
}