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:

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

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

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

中心扩展法 ，时间复杂度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)，且不需要使用额外的空间

动态规划，时间复杂度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)的空间。

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算法（/article/7555634.html）

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