经典问题：最长回文子串

最长回文子串，非常经典的问题。

题意：给定一个字符串，求其最长回文子串。

解法一：暴力解法，找出字符串中的所有子串，【时间复杂度O(n^2)】然后求该子串是不是回文串【时间复杂度O(n)，所以整个算法的时间复杂度是O(n^3)】，并记录其中最长子串的起始位置和长度。代码如下：

class Solution {
public:
    string longestPalindrome(string s){
         const int n = s.length();
         int maxlength = 0;
         int left=0,right = n;
         for(int i = 0;i<n;++i){
             for(int j = i+1;j<n;++j){
                 for(int k = i,t = j;k<t;++k,--t){
                     if(s[k]!=s[t])
                         break;
                 }
                 if(k>=t&&j-i+1>=maxn){
                     // 有回文串
                    left = i;
                    maxlength = j - i + 1;
                 }
             }
         }
         if(maxn>0)
            return s.substr(left,maxn);
         return NULL;
    }
};

解法二：中心扩展法

即把给定的字符串的每一个字母当做中心，向两边扩展，这样来找最长的子回文串。算法复杂度为O(n^2)。

class Solution {
public:
    string longestPalindrome(string s){
          const int length = s.size();
          int maxlength = 0;
          int start=0;
          for(int i = 0;i < length;++i){
               int j = i-1,k=i+1;
               while(j>=0&&k<length&&s[j]==s[k]){
                   if(k-j+1>maxlength){
                       maxlength = k-j+1;
                       start = j;
                   }
                   --j;
                   ++k;
               }
          }
          for(int i = 0;i<length;++i){
              int j = i,k=i+1;
              while(j>=0&&k<length&&s[j]==s[k]){
                  if(k-j+1>maxlength)
                  {
                      maxlength = k-j+1;
                      start = j;
                  }
                  --j;
                  ++k;
              }
          }
          if(maxlength>0)
            return s.substr(start,maxlength);
          return str;
    }
};

解法三：dp问题。

复杂度为O(n^2)。设状态为f(i,j)，表示区间[i,j]是否为回文串，则状态转移方程为

f(i,j)    =     true,                                                  i = j

           =     s[i]=s[j]                                             j=i+1

           =     s[i]=s[j] and f(i+1,j-1)                     j>i+1

这种做法空间复杂度也是O(n^2)。

class Solution {
public:
    string longestPalindrome(string s){
    	const int length = s.size();
    	int maxlength = 0;
    	int start;
    	bool dp[1005][1005] = { false };
    	for (int i = 0; i < length; ++i){
    		//初始化准备
    		dp[i][i] = true;
    		if (i < length - 1 && s[i] == s[i + 1]){
    			dp[i][i + 1] = true;
    			start = i;
    			maxlength = 2;
    		}
    	}
    	for (int k = 3; k <= length; ++k){//子串长度
    		for (int i = 0; i <= length - k; ++i){//子串起始地址
    			int j = i + k - 1;//子串结束地址
    			if (dp[i + 1][j - 1] && s[i] == s[j]){
    				dp[i][j] = true;
    				maxlength = k;
    				start = i;
    			}
    		}
    
    	}
    	if (maxlength >= 2)	return s.substr(start,maxlength);
    	return s;
    }
};

解法四：Manacher's Algorithm，复杂度O(n)，详细解释见：http://articles.leetcode.com/longest-palindromic-substring-part-ii