最长回文字串 leetcode 5 Longest Palindromic Substring

方法一：动态规划

回文字符串去掉收尾字符后依然是回文串，即p[i][j]是回文穿，则p[i+1][j-1]也是回文串；

状态方程和转移方程如下：

p[i][j]=p[i+1][j-1] if(s[i]==s[j])

p[i][j]=false if(s[i]!=s[j])

此处，p[i][j]=true 表示字串[i,j]是回文串，p[i,j]=false表示p[i,j]不是回文，复杂度O（N^2)

考虑到i+1,j-1,所以程序主体处理的是回文字串长度大于等于3的情况，对于长度为1,2提前做处理，C++代码（头文件此处未添加，只是程序主体部分）如下：

		int size = s.size();
		if (size == 0)
		{
			return "";
		}
		vector<vector<bool>>dp;
		vector<bool>temp(size, false);
		dp.resize(size, temp);
		int start, max_len = 1;
		for (int i = 0; i < size; i++)
		{
			dp[i][i] = true;                                                          //length =1
			if (i < size - 1 && s[i] == s[i + 1])
			{
				dp[i][i + 1] = true;
				start = i;
				max_len = 2;                                                   //length=2
			}
		}
		for (int len = 3; len <=size; len++ )                          //len----the length of substr
		{ 
			for (int i = 0; i <= size - len; i++)                     //i---the begin address of substr
			{
				int j = i + len - 1;                                  //j---the end address of substr
				if (dp[i + 1][j - 1] && s[i] == s[j])
				{
					dp[i][j] = true;
					start = i;
					max_len = len;
				}
			}
		}
		if (max_len >= 2)
		{
			return s.substr(start, max_len);
		}
		else
			return s.substr(0,1);          

方法二 ：从中心向两边扩展

考虑到最长回文字串的长度可能是奇数和偶数两种情况，可以先对字符串进行填充某一不出现在字符串中的字符，例如‘#’，这样得到的最长回文字串一定是奇数。将填充后的字符串中每一个字符当做中间字符，向两边扩展，得到最长回文字串，在再删除插入的字符即可。复杂度O（N^2),C++代码如下：

                int size = s.size();
		if (size == 0)
		{
			return "";
		}
		int j = 1;
		for (int i = 0; i < size - 1; i++)
		{
		
			s.insert(j, "#");
			j += 2;
		}
		s.insert(0, "#");
		s.push_back('#');                           //insert length(s)+1 '#',example: abc becomes #a#b#c#   abcd becomes #a#b#c#d#
		int start, max_len = 1;
		for (int i = 1; i < s.size() - 1; i++)
		{
			int j = i - 1, k = i + 1;             // j represent left extention,k represent right extention
			while (j >= 0 && k < s.size() && s[j] == s[k])
			{
				if (k - j + 1>max_len)
				{
					max_len = k - j + 1;
					start = j;
				}
				j--;
				k++;
			}
		}
		s = s.substr(start, max_len);
		string res;
		for (int i = 0; i < s.size(); i++)                //delete the '#'
		{
			if (s[i] != '#')
			{
				res.push_back(s[i]);
			}
		}
		return res;
	}

还有Manacher算法，复杂度O（N）；

对字符串反转，找两个字符串的公共最长字串（动态规划）；

先到这，后续代码写好再补充