Longest Palindromic Substring (LPS) 问题是一个DP中的经典问题。处理这个问题的第一个关键点在于要区分substring和subsequence（我就犯了这样的错误）。substring指的是连续的子字符串，比如abc是abcde的substring, 但abe就不是它的substring，但可以算一个subsequence.
下面介绍这道题的若干种解法。
1）brute force方法。遍历每一对index，取做起点和终点，然后判断这个substring是不是回文。取点的过程花费O(n^2)，判断的过程花费O(n)，所以一共O(n^3)。
2）经典DP方法。时间O(n^2)；空间O(n^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);
}关键步的思路是：对于一个string，如果它的首尾两个char相同，而除去首位以后剩下的是个回文，则这个string本身也是回文。这个方法是最经典最常见的DP解法，但却不是最优解法。在介绍这个解法的升级版之前，先看下面这段代码。它是这个方法的另一种写法：
string longestPalindromeDP(string s) {
int len = s.length();
if (len == 0) return string("");
else if (len == 1) return s;
else if (len == 2) return (s[0] == s[1] ? s : s.substr(0, 1));
bool table[1000][1000] = {false};
string result = s.substr(0, 1);
for (int i = 0; i < len - 1; i ++) {
table[i][i] = true;
if (s[i] ==s[i+1]) {
table[i][i + 1] = true;
result = s.substr(i, 2);
}
}
table[len - 1][len - 1] = true;
for (int l = 3; l <= len; l ++) {
for (int i = 0; i < len - l + 1; i ++) {
int j = i + l - 1;
if (s[i] == s[j] && table[i+1][j-1]) {
table[i][j] = true;
result = s.substr(i, l);
}
}
}
return result;
}可以看到，这段代码跟上面的那一段非常非常相似。唯一细小的差别是，上面的代码每一次记录起始位置和substring的长度，到返回之前再取substring；而这段代码每次直接取substring了。这样看来，上面的代码稍稍更好一点（时间复空间杂度都相同）。但就是这么一点点的区别，在leetcode上的就变成了非常显著的区别：上方代码可以通过大数据测试，但下方的不行，说超时了。事实上，我用time命令和较大的输入跑了两段代码，发现他们的差别是可以忽略不计的。说了这么多废话貌似只表达了leetcode服务器上的计时非常精准。。。
3）节省空间的DP算法。我们的方法2）需要使用O(n^2)的空间。而这里介绍的这种方法同样使用O(n^2)的时间，却可以使用O(1)的extra space。这个算法的思路是，每一个回文的string都是像中间对称的，所以可以由中间“展开”所得。这里的“中间”可以是一个字母（当length为奇数），也可以是两个字母中间的位置（length为偶数）。所以一共有2N-1个“中间”，其中N是字符的个数。而展开需要O(N)的时间，所以一共是O(n^2)。代码如下：
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;
}4）一种非常容易错的DP算法。有些人会想：既然我们要找的是回文，那么如果我把这个string s调转过来，变成s'，然后再找s和s'的最长common substring，不就是我们需要的回文了么？这个思路犯了一个不易察觉的错误。比如：
acbc这个string调过来变成cbca。那么我们找这两个string的common subsequence可以找到cbc，正好是我们需要的最长回文。但下面就有一个反例：
abxyba，调转以后是abyxba那么找到的common string是ab （或ba），但他们不是回文。
从上面的反例我们可以看出，我们不但需要找到最长的common substring，找到以后还要检查一下index看是否对应。所以说做这样一个小改动之后，这个算法还是可以用的。时间和空间复杂度都是O(n^2)。这道题也相应地变成了一个找两个string最长common substring的问题。这也是一个DP经典问题。具体解法请自行google。。
5）终极算法：Manacher’s Algorithm。时间复杂度O(n)。
首先拿到一个字符串S之后，我们在每个字符之间插入一个特殊字符#。比如：abaaba转化成#a#b#a#a#b#a#。这样做的好处是，不论原来的字符长度是奇数还是偶数，转化以后都可以使用相同的方式来处理。针对处理后的字符（我们称之为T），我们建立一个与其长度相同的int数组p。p[i]的含义是以T[i]为中心的回文字符串可以向左右各延伸几个字符。比如上面这个例子中，对应的p数组是：
T = # a # b # a # a # b # a # P = 0 1 0 3 0 1 6 1 0 3 0 1 0我们发现，T中最长的回文substring是以第六个（index从0算起）字符（是一个‘#’）为中心的，左右长度各为6的字符，因为p[6] = 6, 是p中最大的。一个更重要的性质是，以中心为对称轴来观察的话，会发现左右两边的数值是对称的。如果这条性质始终满足的话，我们岂不是可以少了一半的工作量么。我们来看下面一个稍微复杂一点的例子：
S=babcbabcbaccba，对应地T=#b#a#b#c#b#a#b#c#b#a#c#c#b#a#。我们看下面这张图：
假设我们现在来到了i=13的位置。我们可以先看13对应的对称点是多少，发现对称点是9，而p[9] = 1。显而易见，p[13]的值也是1。事实上，以C（此处为11）为中心的左右三个点都是对称的，即p[12] = p[10], p[13] = p[9], p[14] = p[8]。
假设说我们现在来到了i=15的位置：
它的对应点是7，而p[7] = 7。这是否意味着p[15]也等于7呢？不是。因为我们发现以15为中心的最长回文是a#b#c#b#a，左右两边比7要短的多。这是怎么回事呢？我们看下面这张图：
我们看到，绿色实线所覆盖的区域的T是相对C对称的，L和R是左右边界。而在7的位置，对应的数值是7，已经超过了左边界。这种情况下，p的对称原则就不再满足了。我们目前只能知道p[15]的最大值是5（到达右边界为止）。然后我们再继续扩张就会发现，T[21] != T[1]，所以p[15]只能是5了。
所以这个算法的最关键步骤如下：
then P[ i ] ← P[ i' ]
else P[ i ] ≥ P[ i' ]. (Which we have to expand past the right edge (R) to find P[ i ].
// 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);
}注意这段代码的开头处还有一个巧妙的地方在于，在T的首尾各插入了一个不同于'#'的特殊字符，这样就不用进行boundary check了，很方便。
Ref:
http://leetcode.com/2011/11/longest-palindromic-substring-part-i.html
http://leetcode.com/2011/11/longest-palindromic-substring-part-ii.html
3159
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
