Leetcode | 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.

Method I

之前先做了Palindrome Partitioning，所以一开始也用二维动态规划来做，vector<vector<int> > 报MLE。

然后又用和Minimum Window Substring同样的思路，在[0...i]找包含s[i]的最长回文串，最后再求最大。

在找包含s[i]的最长回文串时，首先保存了包含s[i-1]的最长回文串的长度pre，如果s[i]=s[i - pre - 1]，那么从s[i-pre-1...i]是回文串，包含s[i]的最长回文串长度就是pre+2。

如果s[i]!=s[i - pre - 1]，那么就从i - pre开始找包含s[i]的最长回文串。

最后取最长的回文串。算法复杂度O(n^2)。空间复杂度O(1)。

class Solution {
public:
    
    bool isPalindrome(string &str, int s, int e) {
        while (s <= e) {
            if (str[s] != str[e]) return false;
            s++;
            e--;
        }
        return true;
    }
    
    string longestPalindrome(string s) {
        int n = s.length();
        if (n <= 1) return s;
        
        int max = 1, start = 0, pre = 0;
        for (int i = 1; i < n; ++i) {
            int j = i - pre - 1;
            if (s[i] == s[j]) {
                pre += 2;
            } else {
                for (j++; j <= i; ++j) {
                    if (isPalindrome(s, j, i)) {
                        pre = i - j + 1;
                        break;
                    }
                }
            }
            if (pre > max) {
                max = pre;
                start = j;
            }
        }
        return s.substr(start, max);
    }
};

 Method II

以下摘自http://leetcode.com/2011/11/longest-palindromic-substring-part-i.html

二维dp。时间复杂度O(n^2)。空间复杂度O(n^2)。用table[1000][1000]就能通过，用vector<vector<int> > 报MLE，用vector<vector<bool> >报TLE。看来以后dp还是用数组来做快些。 

这里dp的构建过程和平常不一样，不是一个位置一个位置移动去构建，而是按长度来构建。len=1,2,....

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

Method III

从中心扩展的方法。时间复杂度O(n^2)。空间复杂度O(1)。

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

Method VI

 非常巧妙的方法。看了解释之后理解还是有些困难。

思路大概是这样子：

首先把原串S每两个字符之间插入一个#，存为T。这样做的好处是可以无差别地处理奇数和偶数的palindrome串。

如图，维护一个palindrome区间，[L,R]，以C作为中心。可以看到数组p就是以每个位置为中心的palindrome串的长度。

i和i'关于C成镜像，也就是i'=C*2-i。

如果i>=R，P[i]=0.

否则，如果P[i']<=R-i，那么P[i]=P[i']，对称的；

如果P[i']>R-i，那么我们的是就要尝试扩展一下R；

如果成功扩展了，也就是i+P[i]>R，那么就移动中心C，C=i，扩展R=i+P[i]；

最后再求一下P的最大值；

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

Line 26-27内循环，可以看作是扩展R的步骤，R在整个代码中是只增不减的，总的最多扩展n步，所以整个算法是2n的开销，时间复杂度为O(n)，空间复杂度也是O(n)。

事后诸葛

对于这类，要求某个最优区间的。可以考虑：

1. 和Minimum Window Substring同样的思路，在[0...i]找包含s[i]的最优区间。然后再取最优；

2. 也可以尝试Method II，二维动态规划，构建的时候以区间长度来构建。