标签：style blog class code c java
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.
之前先做了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)。
1 class Solution { 2 public: 3 4 bool isPalindrome(string &str, int s, int e) { 5 while (s <= e) { 6 if (str[s] != str[e]) return false; 7 s++; 8 e--; 9 } 10 return true; 11 } 12 13 string longestPalindrome(string s) { 14 int n = s.length(); 15 if (n <= 1) return s; 16 17 int max = 1, start = 0, pre = 0; 18 for (int i = 1; i < n; ++i) { 19 int j = i - pre - 1; 20 if (s[i] == s[j]) { 21 pre += 2; 22 } else { 23 for (j++; j <= i; ++j) { 24 if (isPalindrome(s, j, i)) { 25 pre = i - j + 1; 26 break; 27 } 28 } 29 } 30 if (pre > max) { 31 max = pre; 32 start = j; 33 } 34 } 35 return s.substr(start, max); 36 } 37 };
以下摘自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,....
1 string longestPalindromeDP(string s) { 2 int n = s.length(); 3 int longestBegin = 0; 4 int maxLen = 1; 5 bool table[1000][1000] = {false}; 6 for (int i = 0; i < n; i++) { 7 table[i][i] = true; 8 } 9 for (int i = 0; i < n-1; i++) { 10 if (s[i] == s[i+1]) { 11 table[i][i+1] = true; 12 longestBegin = i; 13 maxLen = 2; 14 } 15 } 16 for (int len = 3; len <= n; len++) { 17 for (int i = 0; i < n-len+1; i++) { 18 int j = i+len-1; 19 if (s[i] == s[j] && table[i+1][j-1]) { 20 table[i][j] = true; 21 longestBegin = i; 22 maxLen = len; 23 } 24 } 25 } 26 return s.substr(longestBegin, maxLen); 27 }
从中心扩展的方法。时间复杂度O(n^2)。空间复杂度O(1)。
1 string expandAroundCenter(string s, int c1, int c2) { 2 int l = c1, r = c2; 3 int n = s.length(); 4 while (l >= 0 && r <= n-1 && s[l] == s[r]) { 5 l--; 6 r++; 7 } 8 return s.substr(l+1, r-l-1); 9 } 10 11 string longestPalindromeSimple(string s) { 12 int n = s.length(); 13 if (n == 0) return ""; 14 string longest = s.substr(0, 1); // a single char itself is a palindrome 15 for (int i = 0; i < n-1; i++) { 16 string p1 = expandAroundCenter(s, i, i); 17 if (p1.length() > longest.length()) 18 longest = p1; 19 20 string p2 = expandAroundCenter(s, i, i+1); 21 if (p2.length() > longest.length()) 22 longest = p2; 23 } 24 return longest; 25 }
非常巧妙的方法。看了解释之后理解还是有些困难。
思路大概是这样子：
首先把原串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的最大值；
1 // Transform S into T. 2 // For example, S = "abba", T = "^#a#b#b#a#$". 3 // ^ and $ signs are sentinels appended to each end to avoid bounds checking 4 string preProcess(string s) { 5 int n = s.length(); 6 if (n == 0) return "^$"; 7 string ret = "^"; 8 for (int i = 0; i < n; i++) 9 ret += "#" + s.substr(i, 1); 10 11 ret += "#$"; 12 return ret; 13 } 14 15 string longestPalindrome(string s) { 16 string T = preProcess(s); 17 int n = T.length(); 18 int *P = new int[n]; 19 int C = 0, R = 0; 20 for (int i = 1; i < n-1; i++) { 21 int i_mirror = 2*C-i; // equals to i‘ = C - (i-C) 22 23 P[i] = (R > i) ? min(R-i, P[i_mirror]) : 0; 24 25 // Attempt to expand palindrome centered at i 26 while (T[i + 1 + P[i]] == T[i - 1 - P[i]]) 27 P[i]++; 28 29 // If palindrome centered at i expand past R, 30 // adjust center based on expanded palindrome. 31 if (i + P[i] > R) { 32 C = i; 33 R = i + P[i]; 34 } 35 } 36 37 // Find the maximum element in P. 38 int maxLen = 0; 39 int centerIndex = 0; 40 for (int i = 1; i < n-1; i++) { 41 if (P[i] > maxLen) { 42 maxLen = P[i]; 43 centerIndex = i; 44 } 45 } 46 delete[] P; 47 48 return s.substr((centerIndex - 1 - maxLen)/2, maxLen); 49 }
Line 26-27内循环，可以看作是扩展R的步骤，R在整个代码中是只增不减的，总的最多扩展n步，所以整个算法是2n的开销，时间复杂度为O(n)，空间复杂度也是O(n)。
对于这类，要求某个最优区间的。可以考虑：
1. 和Minimum Window Substring同样的思路，在[0...i]找包含s[i]的最优区间。然后再取最优；
2. 也可以尝试Method II，二维动态规划，构建的时候以区间长度来构建。
Leetcode | Longest Palindromic Substring,布布扣,bubuko.com
Leetcode | Longest Palindromic Substring
标签：style blog class code c java
原文地址：http://www.cnblogs.com/linyx/p/3725240.html
