Longest Palindromic Substring

给定一个字符串，求该字符串中最长的回文子串。如字符串“abcdcdgh”的最长回文子串为“bcdcb”

有一个常见的错误解法：翻转给定的字符串，找出原字符串和翻转后的字符串的最长公共子串就是要找的最长回文子串。这种方法貌似可以，比如S="caba"，S'=“abac”，那么S和S'的最长公共子串就是“aba”，也就是要找的最长回文子串，但是，假如S=“abacdfgdcaba”，S'=“abacdgfdcaba”，那么S和S'的最长公共子串就是“abacd”，显然不是要找的最长回文子串。

暴力法：我们可以选择每种可能的起始和终止位置子串，并确认该子串是否回文。这种方法的复杂度为O(N*N*N)。

动态规划：考虑字符串“ababa”，假如已经知道“aba”是回文的，那么“ababa”一定是回文的，因为左右两个字符是相同的。

string longestDP(string s)
{
	int i;
	int n = s.length();
	int longestBegin = 0;
	int maxLen = 1;
	bool table[100][100] = {false};
	for (i = 0; i < n; i++)
	{
		table[i][i] = true;
	}

	for (i = 0; i < n - 1; i++)
	{
		if (s[i] == s[i + 1])
		{
			table[i][i + 1] = true;
			longestBegin = i;
			maxLen = 2;
		}
	}
	for (int len = 3; len <= n; len++)
	{
		for (i = 0; i < n - len + 1; i++)
		{
			int j = i + len - 1;
			if (s[i] == s[j] && table[i + 1][j - 1])
			{
				table[i][j] = true;
				longestBegin = i;
				maxLen = len;
			}
		}
	}

	return s.substr(longestBegin, maxLen);
}

动态规划时间复杂度为O(N*N)，空间复杂度为O(N*N)。

更简洁的方法：我们发现回文字符串是关于中心对称的，那么回文字符串就可以从中心展开，并且有2N-1个这样的中心。有2N-1个中心而不是N个是因为中心可能在两个字符的中间，比如“abba”的中心就在两个b中间。

string expandAroundCenter(string s, int m, int n)
{
	int left = m, right = n;
	int len = s.length();
	while (left >= 0 && right <= len - 1 && s[left] == s[right])
	{
		left--;
		right++;
	}
	return s.substr(left + 1, right - left - 1);
}

string longestP(string s)
{
	int n = s.length();
	if (0 == n)
		return "";

	string longest = s.substr(0, 1);

	for (int i = 0; i < n - 1; i++)
	{
		string p1 = expandAroundCenter(s, i, i);
		if (p1.length() > longest.length())
			longest = p1;

		string p2 = expandAroundCenter(s, i, i + 1);
		if (p2.length() > longest.length())
			longest = p2;
	}

	return longest;
}

这种方法时间复杂度仍为O(N*N)，但空间复杂度降为O(1)。