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.

方法一（暴力解法）：

就上暴力加些剪枝。

枚举回文串的长度，从最长的开始，寻找是否有当前长度的回文串。

如果找到，直接弹出循环，没找到就减小回文串的长度。

l记录满足条件的回文串在原串中的下标，r记录回文串的长度。

class Solution {
public:
    string longestPalindrome(string s) {
        int i,j,k,len=s.length(),l=0,r=1;
        for(k=len;k>=2;--k)
        {
            for(i=0;i+k<=len;++i)        
            {
                for(j=0;j<k/2;++j)
                {
                    if(s[i+j]!=s[i+k-j-1])break;
                }
                if(j!=k/2)continue;
                else
                {
                    l=i;r=k;
                }
            }
            if(r==k)break;
        }
        
        string temp;
        return temp.assign(s,l,r);
    }
};

方法二（动态规划）：（以下三种算法的描述转自：http://blog.csdn.net/feliciafay/article/details/16984031）

更简洁的做法，使用动态规划，这样可以把时间复杂度降到O(N²)，空间复杂度也为O(N²)。做法如下:

首先，写出动态转移方程。

Define P[ i, j ] ← true iff the substring Si … Sj is a palindrome, otherwise false.

P[ i, j ] ← ( P[ i+1, j-1 ] and Si = Sj ) ，显然，如果一个子串是回文串，并且如果从它的左右两侧分别向外扩展的一位也相等，那么这个子串就可以从左右两侧分别向外扩展一位。

其中的base case是

P[ i, i ] ← true
P[ i, i+1 ] ← ( Si = Si+1 )  （这里需要单独考虑，因为）

然后，看一个例子。

假设有个字符串是adade，现在要找到其中的最长回文子串。使用上面的动态转移方程，有如下的过程:

按照红箭头->黄箭头->蓝箭头->绿箭头->橙箭头的顺序依次填入矩阵，通过这个矩阵记录从i到j是否是一个回文串。

代码如下：

    //动态规划算法  
    string longestPalindromeDP(string s) {  
      int n = s.length();  
      int longestBegin = 0;  
      int maxLen = 1;  
      bool table[1000][1000] = {false};  
      for (int i = 0; i < n; i++) {  
        table[i][i] = true;  
      }  
      for (int 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 (int 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²)的算法-从中间向两边展开

回文字符串显然有个特征是沿着中心那个字符轴对称。比如aha沿着中间的h轴对称，a沿着中间的a轴对称。那么aa呢？沿着中间的空字符''轴对称。
所以对于长度为奇数的回文字符串，它沿着中心字符轴对称，对于长度为偶数的回文字符串，它沿着中心的空字符轴对称。
对于长度为N的候选字符串，我们需要在每一个可能的中心点进行检测以判断是否构成回文字符串，这样的中心点一共有2N-1个(2N-1=N-1 + N)。
检测的具体办法是，从中心开始向两端展开，观察两端的字符是否相同。代码如下:

    //从中间向两边展开  
    string expandAroundCenter(string s, int c1, int c2) {  
      int l = c1, r = c2;  
      int n = s.length();  
      while (l >= 0 && r <= n-1 && s[l] == s[r]) {  
        l--;  
        r++;  
      }  
      return s.substr(l+1, r-l-1);  
    }  
       
    string longestPalindromeSimple(string s) {  
      int n = s.length();  
      if (n == 0) return "";  
      string longest = s.substr(0, 1);  // a single char itself is a palindrome  
      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;  
    }  

方法四（Manacher 线性算法）：

    // Transform S into T.  
    // For example, S = "abba", T = "^#a#b#b#a#$".  
    // ^ and $ signs are sentinels appended to each end to avoid bounds checking  
    string preProcess(string s) {  
      int n = s.length();  
      if (n == 0) return "^$";  
      string ret = "^";  
      for (int i = 0; i < n; i++)  
        ret += "#" + s.substr(i, 1);  
       
      ret += "#$";  
      return ret;  
    }  
       
    string longestPalindrome(string s) {  
      string T = preProcess(s);  
      int n = T.length();  
      int *P = new int[n];  
      int C = 0, R = 0;  
      for (int i = 1; i < n-1; i++) {  
        int i_mirror = 2*C-i; // equals to i' = C - (i-C)  
          
        P[i] = (R > i) ? min(R-i, P[i_mirror]) : 0;  
          
        // Attempt to expand palindrome centered at i  
        while (T[i + 1 + P[i]] == T[i - 1 - P[i]])  
          P[i]++;  
       
        // If palindrome centered at i expand past R,  
        // adjust center based on expanded palindrome.  
        if (i + P[i] > R) {  
          C = i;  
          R = i + P[i];  
        }  
      }  
       
      // Find the maximum element in P.  
      int maxLen = 0;  
      int centerIndex = 0;  
      for (int i = 1; i < n-1; i++) {  
        if (P[i] > maxLen) {  
          maxLen = P[i];  
          centerIndex = i;  
        }  
      }  
      delete[] P;  
        
      return s.substr((centerIndex - 1 - maxLen)/2, maxLen);  
    }