LeetCode--5. Longest Palindromic Substring

Problem:

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.

Analysis:
这个题目有四种解答方法：

1. 两侧比较法，时间复杂度O(n^3) ，空间复杂度O(1)

   这个方法严重超时，一点优化都没有。就是进行群遍历

2. 中心扩展法 ，时间复杂度O(n^2)，空间复杂度O(1)

   因为回文字符串是以中心轴对称的，所以如果我们从下标 i 出发，用2个指针向 i 的两边扩展判断是否相等，那么只需要对0到n-1的下标都做此操作，就可以求出最长的回文子串。但需要注意的是，回文字符串有奇偶对称之分，即”abcba”与”abba”2种类型，因此需要在代码编写时都做判断。
   设函数int Palindromic ( string &s, int i ,int j) 是求由下标 i 和 j 向两边扩展的回文串的长度，那么对0至n-1的下标，调用2次此函数：
   int lenOdd = Palindromic( str, i, i ) 和 int lenEven = Palindromic (str , i , j )，即可求得以i 下标为奇回文和偶回文的子串长度。接下来以lenOdd和lenEven中的最大值与当前最大值max比较即可。这个方法有一个好处是时间复杂度为O(n2)，且不需要使用额外的空间

3. 动态规划，时间复杂度O(n^2)，空间复杂度O(n^2)

   假设dp[ i ][ j ]的值为true，表示字符串s中下标从 i 到 j 的字符组成的子串是回文串。那么可以推出：
   dp[ i ][ j ] = dp[ i + 1][ j - 1] && s[ i ] == s[ j ]。
   这是一般的情况，由于需要依靠i+1, j -1，所以有可能 i + 1 = j -1, i +1 = (j - 1) -1，因此需要求出基准情况才能套用以上的公式：
   a. i + 1 = j -1，即回文长度为1时，dp[ i ][ i ] = true;
   b. i +1 = (j - 1) -1，即回文长度为2时，dp[ i ][ i + 1] = （s[ i ] == s[ i + 1]）。
   有了以上分析就可以写出代码了。需要注意的是动态规划需要额外的O(n2)的空间。

4. O(n) 马拉车（Manacher算法），时间复杂度O(n)，空间复杂度O(n^2)

   时间复杂度为什么是O(N)而不是O(N²)呢？
   时间复杂度为什么是O(N)？
   假设真的是O(N²)，那么在每次外层的for循环进行的时候（一共n步），对于for的每一步，内层的while循环要进行O(N)次。而这是不可能。因为p[i]和R是有相互影响的。while要么就只走一步，就到了退出条件了。要么就走很多很步。如果while走了很多步，多到一定程度，会更新R的值，使得R的值增大。而一旦R变大了，下一次进行for循环的时候，while条件直接就退出了。
   附：
   解法： http://articles.leetcode.com/longest-palindromic-substring-part-ii
   Manacher算法（http://blog.csdn.net/hk2291976/article/details/51107886）

Answer:

• O(n^3) 两侧比较法

public class Solution {
    public String longestPalindrome(String s) { 
        int maxPalinLength = 0;  
        String longestPalindrome = s;  
        int length = s.length();  
        // check all possible sub strings 
        for (int i = 0; i < length; i++) {  
            for (int j = i + 1; j < length; j++) {  
                int len = j - i;  
                String curr = s.substring(i, j + 1);  
                if (isPalindrome(curr)) {  
                    if (len > maxPalinLength) {  
                        longestPalindrome = curr;  
                        maxPalinLength = len;  
                    }  
                }  
            }  
        }  

        return longestPalindrome; 
    }

    public static boolean isPalindrome(String s) {  
        for (int i = 0; i < s.length() - 1; i++) {  
            if (s.charAt(i) != s.charAt(s.length() - 1 - i)) {  
                return false;  
            }  
        }  
        return true;  
    }  
} 

• 中心扩展法

public class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 2) {
            return s;
        }
        String longest = s.substring(0, 1);  
        for (int i = 0; i < s.length(); i++) {  
            // get longest palindrome with center of i 
            String tmp = helper(s, i, i);  
            if (tmp.length() > longest.length()) {  
                longest = tmp;  
            }  
            // get longest palindrome with center of i, i+1 
            tmp = helper(s, i, i + 1);  
            if (tmp.length() > longest.length()) {  
                longest = tmp;  
            }  
        }  
        return longest;  
    }  

    // Given a center, either one letter or two letter, Find longest palindrome 
    public static String helper(String s, int begin, int end) {  
        while (begin >= 0 && end <= s.length() - 1  
                && s.charAt(begin) == s.charAt(end)) {  
            begin--;  
            end++;  
        }  
        return  s.substring(begin + 1, end);  
    }  
}

• 动态规划

public class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 2) {
            return s;
        }

        int maxLength = 0;
        String longest = null;
        int length = s.length();
        boolean[][] table = new boolean[length][length];

        // 单个字符都是回文
        for (int i = 0; i < length; i++) {
            table[i][i] = true;
            longest = s.substring(i, i + 1);
            maxLength = 1;
        }

        // 判断两个字符是否是回文
        for (int i = 0; i < length - 1; i++) {
            if (s.charAt(i) == s.charAt(i + 1)) {
                table[i][i + 1] = true;
                longest = s.substring(i, i + 2);
                maxLength = 2;
            }
        }

        // 求长度大于2的子串是否是回文串
        for (int len = 3; len <= length; len++) {
            for (int i = 0, j; (j = i + len - 1) <= length - 1; i++) {
                if (s.charAt(i) == s.charAt(j)) {
                    table[i][j] = table[i + 1][j - 1];
                    if (table[i][j] && maxLength < len) {
                        longest = s.substring(i, j + 1);
                        maxLength = len;
                    }
                } else {
                    table[i][j] = false;
                }
            }
        }
        return longest;
    }
}

• 马拉车

// 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);
}