Leetcode---Longest Palindromic Substring

最长回文字串（Longest Palindromic Substring）

题目：Given a string S, find the longest palindromic substring in S. You may assume that the             maximum length of S is 1000, and there exists one unique longest palindromic substring.

题目连接：https://leetcode.com/problems/longest-palindromic-substring/

    大意是给定一个字符串S，求S中最长的回文字串，回文字符串是指从坐到右和从右到左都是一样的字符串，例如：“西湖回游鱼游回湖西”、“ABDCDBA”、“abccba”等等诸如此类的字符串，单个字符的串，也是回文串。

思路1：暴力解法，枚举S的所有字串，判断每个字符串是否是回文串，返回最长的串，当字符串很长的时候，枚举也只能想想了，更别说还要判断是否是回文。

思路2：枚举中心法，我们感兴趣的只是串中的回文字串，因为回文串的性质，那么我们可以枚举串中每一个字符，来检查以它为中心的串是不是回文串，并选取其中最长的返回。

     

     例如： ABDCDBA  

    1.以A为中心，A的左边没有字符，所以只能是A当作一个回文。

2.以B为中心，那么比较B的左边和右边字符是否相等。相等，是回文。否则，不是。

3.以此类推，直到所有的字符作为中心判断完。

假设以i为中心，j为i左右的长度，且满足条件1：(i-j)>=0 && (i+j)<S.size(); j从0开始，到不能满足条件1结            束，分别判断，判断完成以i为中心后，以i+1为中心再进行类似判断。当然还有一个问题，就是回文串的长度有          可能是奇数，也可能是偶数。例如ABA、ABBA都是回文。这个时候只需要对奇数还是偶数进行分别判断：

               奇数时：判断S[i-j] == S[i+j]，j满足(i-j)>=0 && (i+j)<S.size()。

       偶数使：判断S[i-j] == S[i+j+1]，j满足(i-j)>=0 && (i+j+1)<S.size()

CODE: 

             

string LongestPalindrome( string s)
{
    int start=0,maxLen = 1,tlen = 1,ti=0;
    int size = s.size();
    
    if( size <= 1 )
        return s;
    
    
    // 奇数
    for( int i = 0; i < size; i++)
    {
        for( int j = 0; (i-j>=0) && (i+j
   
    = maxlen )
        {
            maxlen = tlen;
            start = i-j;
        }
        
        
          // 偶数
        for( int j = 0; (i-j>=0) && (i+j+1 <= n); ++j )
        {
            if( s[i-j] != s[i+j+1])
                break;
            tlen = 2*j+2;
            ti = i-j;
        }
        
        if(tlen > maxlen )
        {
            maxlen = tlen;
            start = ti;
        }
    }
    
    return s.substr(start,maxlen);


}
   

思路3：先看下面的例子：

     A  AABABBAABCBABC ....

      可以看出什么？ A按规定是一个回文，要判断BAB是不是回文，那么判断B==B，且A是不是回文。判断BAAB，则判断B==B? 且AA是不是回文。以此类推，可以总结    到：

1.单个字符是回文。

2.两个字符相同是回文，否则不是。

3.长度大于等于3的串，满足s[0]==s[s.size-1] && s.substr(1,s.size-2)是不是回文。满足则是，否则不是。

   更一般化来讲：

对于以i为起点，j为长度的string是不是回文串，只需要判断，s[i]==s[s+j-1]且s[i+1 to i+j-2]之间的串是不是回文串，这样问题规模就减小了，对于规模    大的问题转换到小规模问题求解，那么很容易想到的就是动态规划。

    DP[i][i] = true;    i<s.size();

DP[i][i+1] = true；  if( s[i]==s[i+1] && i<s.size()-1)

DP[i][j] = true;    if( s[i]==s[j] && DP[i+1][j-1] && i<size & j < size)

   按照这个思路很自然可以得出代码：

   CODE

   

string longestPalindrome(string s) {
   
        const int size = s.size();
        if( size == 1)
            return s;
            
        bool dp[1000][1000] ;
        
        for( int i = 0; i < 1000; i++)
            memset(dp[i],false,1000);
            
        int maxlen =1;
        int start = 0;
        
        for( int i = 0; i < 1000; i++)
        {
            dp[i][i]= true;
            if( i<(size-1) && (s[i] == s[i+1]))
            {
                dp[i][i+1]=true;
                start = i;
                maxlen = 2;
            }
        }
        
        for( int len = 3; len <= size; len++)
        {
            for(int i = 0; i < size-len+1; i++)
            {
                int j = i+len-1;
                if( dp[i+1][j-1] && (s.at(i)==s.at(j)))
                {
                    dp[i][j] = true;
                    start = i;
                    maxlen = len;
                }
            }
        }
        
        if( maxlen >= 2)
        {
            return s.substr(start,maxlen);
        }
        
        return NULL;
    }

  抛开暴力枚举的方法，因为效率太低了，中心枚举和动态规划的时间复杂度都是O(n^2),还有没有更高效的方法呢？当然有，这就是传说中的Manacher算法，这个方法需要点想象力啊。

思路4：Manacher算法，这就是个传说。 Manacher算法思想是来自上述“中心扩展法”，在“中心法”中要考虑回文 串是奇数还是偶数，有没办法统一处理呢？有，这就是Manacher算法。

    该算法首先将字符串的每个字符之间加入一个特殊字符，并且在字符串开头加入一个标志来更好处理越界和编码问题。例如：s=“abba”编码后是：s=“$#a#b#b#a#”。

   然后，用一个数组p来记录每个字符是s[i]为中心的的回文串向左或向右的长度，则原字符串s的回文长度为max(p[i]-1)。因为对于一个回文字符串s加入特殊字符后，该回文串加上特殊字符后依然会是一个回文串，且编码后的回文串的长度为2*s.size+1。那么数组记录的最大值为s.size+1，比原回文的长度多1。故求取p[]的最大值减1就是原字符串中最大的回文串。

   现在最重要的问题就是怎么求解p[],这似乎又回到原来开始的问题了，非也。因为加了特殊字符，会出现一些有用的结论。

   假设现在求p[i]的值，则p[0]...p[i-1]的值已经求出，maxlen为目前已经求出的回文串延伸到右边的最大长度，id为p[0]到p[i-1]最大回文串的中心，j为i关于id的对称点，即j=2*id-i。那么：

   1.如果i不在maxlen范围内，即不在任何回文串中,则p[i]=1（本身为回文）。接着判断p[i+j]==p[i-j]，为真则++p[i]，否则2；

   2.p[i]>=min(p[2id-i],maxlen-i]。
   证明：

情况1：

         

情况2：

情况3：

int Manacher(string s)
{
	int len = s.size();
	int maxLen = 0;
	int id;
	int mx = 0;

	for (int i = 1; i < len; i++)
	{
		if (i < maxLen)
			p[i] = min(p[2 * id - i], maxLen - i);
		else
			p[i] = 1;

		while (s_new[i - p[i]] == s_new[i + p[i]])
			p[i]++;


		if (maxLen < i + p[i])
		{
			id = i;
			maxLen = i + p[i];
		}

		mx = max(mx, p[i] - 1);
	}

	return mx;
}