LeetCode 5 -- Longest Palindromic Substring

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

---

第一种方法比较直接，实现起来比较容易理解。基本思路是对于每个子串的中心（可以是一个字符，或者是两个字符的间隙，比如串abc,中心可以是a,b,c,或者是ab的间隙，bc的间隙）往两边同时进行扫描，直到不是回文串为止。假设字符串的长度为n,那么中心的个数为2*n-1(字符作为中心有n个，间隙有n-1个）。对于每个中心往两边扫描的复杂度为O(n),所以时间复杂度为O((2*n-1)*n)=O(n^2),空间复杂度为O(1)，代码如下：

package Leetcode;

//提交时成功的，为什么结果却只是首字母？

public class LongestPalindromeSubstring {
    public static String longestPalindrome(String s) {
        if (s == null || s.length() == 0)
            return "";
        int maxLen = 0;
        String res = "";

        for (int i = 0; i < 2*s.length() - 1; i++) {
             int left = i / 2;
            int right = i / 2;
            if (i % 2 == 1)
                right++;

            String str = lengthOfPalindrome(s, left, right);

            if (str.length() > maxLen) {
                res = str;
                maxLen = str.length();
            }
        }
        return res;
    }

    public static String lengthOfPalindrome(String str, int left, int right) {
        while (left >= 0 && right < str.length()
                && str.charAt(left) == str.charAt(right)) {
            left--;
            right++;
        }
        return str.substring(left + 1, right);
    }
    
    public static void main(String[] args){
        String str = "sabcbafds";
        String res = longestPalindrome(str);
        System.out.println(res);
    }

}

而第二种方法是用动态规划，思路比较复杂一些，但是实现代码会比较简短。基本思路是外层循环i从后往前扫，内层循环j从i当前字符扫到结尾处。过程中使用的历史信息是从i+1到n之间的任意子串是否是回文已经被记录下来，所以不用重新判断，只需要比较一下头尾字符即可。这种方法使用两层循环，时间复杂度是O(n^2)。而空间上因为需要记录任意子串是否为回文，需要O(n^2)的空间，代码如下：

public String longestPalindrome(String s) {
  if(s == null || s.length()==0)
    return "";
  boolean[][] palin = new boolean[s.length()][s.length()];
  String res = "";
  int maxLen = 0;
  for(int i=s.length()-1;i>=0;i--)
  {
    for(int j=i;j<s.length();j++)
    {
      if(s.charAt(i)==s.charAt(j) && (j-i<=2 || palin[i+1][j-1]))
      {
        palin[i][j] = true;
        if(maxLen<j-i+1)
        {
          maxLen=j-i+1;
          res = s.substring(i,j+1);
        }
      }
    }
  }
  return res;
}

还有另外一种更简单的方法，复杂度O(n)，但没怎么搞懂

参考 http://leetcode.com/2011/11/longest-palindromic-substring-part-ii.html

// Manacher algorithm
 
// Transform S into T
// For example, S = "abba", T = "^#a#b#b#a#$"
// ^ and $ signs are sentinels appended to each string
// to avoid bound 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 longestPalindromeManacher(string s)
{
  string T = preProcess(s);
  int n = T.length();
  vector<int> p(n, 0);
  int C = 0, R = 0;
  for (int i = 1; i < n-1; ++i){
    int i_mirror = 2*C-i;
 
    p[i] = (i < R) ? 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(p[i] + 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;
    }
  }
  return s.substr((centerIndex - 1 - maxLen)/2 , maxLen);
}