题目描述
给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。
示例 1：
输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。
示例 2：
输入: "cbbd"
输出: "bb"
DP
直接枚举复杂度过高为O（n3），用DP可以将复杂度降到O(n2),枚举中心往两边找复杂度也是O（n^2）
枚举:在求解过程中，基数的回文子串与偶数的回文子串是不一样的。比如最长回文子串为aba，对称中心就是b，如果最长回文子串为abba，则对称中心应该为两个b之间，为了解决这个问题，可以在每个字符两边加上一个符号，具体什么符号（是字符串里面的符号也行）对结果没有影响，比如加上“#”，则上述的两个序列变成了#a#b#a#和#a#b#b#a#，求出的长度分别为6和9，再除以2就可以得到最后的结果3和4。
DP:对于字符串s，假设dp[i,j]=1表示s[i...j]是回文子串，那个必定存在dp[i+1,j-1]=1。这样最长回文子串就能分解成一系列子问题，可以利用动态规划求解了。
- dp[i][j]=d[i+1][j-1],s[i]=s[j]
- dp[i][j]=0,s[i]!=s[j]
代码
class Solution {
private:
int dp[1010][1010];
public:
string longestPalindrome(string s) {
int len = s.size();
if (len == 0)return "";
if (len == 1)return s;
int ans = 1, st = 0;
dp[0][0] = 1;
for (int i = 1; i < len; i++) {//初始化单个字符或者两个字符的情况
dp[i][i] = 1;
if (s[i] == s[i - 1]) {
dp[i - 1][i] = 1;
ans = 2;
st = i - 1;
}
}
for (int l = 3; l <= len; l++) {//枚举子串的长度
for (int i = 0; i + l - 1 < len; i++) {//枚举子串的起点
int j = i + l - 1;//终点
if (s[i] == s[j] && dp[i + 1][j - 1] == 1) {
dp[i][j] = 1;
st = i;
ans = l;
}
}
}
return s.substr(st, ans);
}
};
Manacher（马拉车）
作者：windliang
链接：https://www.zhihu.com/question/37289584/answer/465656849
来源：知乎
首先我们解决下奇数和偶数的问题，在每个字符间插入"#"，并且为了使得扩展的过程中，到边界后自动结束，在两端分别插入 "^" 和 "$"，两个不可能在字符串中出现的字符，这样中心扩展的时候，判断两端字符是否相等的时候，如果到了边界就一定会不相等，从而出了循环。经过处理，字符串的长度永远都是奇数了。
首先我们用一个数组 P 保存从中心扩展的最大个数，而它刚好也是去掉 "#" 的原字符串的总长度。例如下图中下标是 6 的地方。可以看到 P[ 6 ] 等于 5，所以它是从左边扩展 5 个字符，相应的右边也是扩展 5 个字符，也就是 "#c#b#c#b#c#"。而去掉 # 恢复到原来的字符串，变成 "cbcbc"，它的长度刚好也就是 5。
求原字符串下标
用 P 的下标 i 减去 P [ i ]，再除以 2 ，就是原字符串的开头下标了。
例如我们找到 P[ i ] 的最大值为 5 ，也就是回文串的最大长度是 5 ，对应的下标是 6 ，所以原字符串的开头下标是 （6 - 5 ）/ 2 = 0 。所以我们只需要返回原字符串的第 0 到 第 （5 - 1）位就可以了。
求每个 P [ i ]
接下来是算法的关键了，它充分利用了回文串的对称性。
我们用 C 表示回文串的中心，用 R 表示回文串的右边半径。所以 R = C + P[ i ] 。C 和 R 所对应的回文串是当前循环中 R 最靠右的回文串。
让我们考虑求 P [ i ] 的时候，如下图。
用 i_mirror 表示当前需要求的第 i 个字符关于 C 对应的下标。
我们现在要求 P [ i ]， 如果是用中心扩展法，那就向两边扩展比对就行了。但是我们其实可以利用回文串 C 的对称性。i 关于 C 的对称点是 i_mirror ，P [ i_mirror ] = 3，所以 P [ i ] 也等于 3 。
但是有三种情况将会造成直接赋值为 P [ i_mirror ] 是不正确的，下边一一讨论。
1. 超出了 R
当我们要求 P [ i ] 的时候，P [ mirror ] = 7，而此时 P [ i ] 并不等于 7 ，为什么呢，因为我们从 i 开始往后数 7 个，等于 22 ，已经超过了最右的 R ，此时不能利用对称性了，但我们一定可以扩展到 R 的，所以 P [ i ] 至少等于 R - i = 20 - 15 = 5，会不会更大呢，我们只需要比较 T [ R+1 ] 和 T [ R+1 ]关于 i 的对称点就行了，就像中心扩展法一样一个个扩展。
2. P [ i_mirror ] 遇到了原字符串的左边界
此时P [ i_mirror ] = 1，但是 P [ i ] 赋值成 1 是不正确的，出现这种情况的原因是 P [ i_mirror ] 在扩展的时候首先是 "#" == "#" ，之后遇到了 "^"和另一个字符比较，也就是到了边界，才终止循环的。而 P [ i ] 并没有遇到边界，所以我们可以继续通过中心扩展法一步一步向两边扩展就行了。
3. i 等于了 R
此时我们先把 P [ i ] 赋值为 0 ，然后通过中心扩展法一步一步扩展就行了。
考虑 C 和 R 的更新
就这样一步一步的求出每个 P [ i ]，当求出的 P [ i ] 的右边界大于当前的 R 时，我们就需要更新 C 和 R 为当前的回文串了。因为我们必须保证 i 在 R 里面，所以一旦有更右边的 R 就要更新 R。
此时的 P [ i ] 求出来将会是 3 ，P [ i ] 对应的右边界将是 10 + 3 = 13，所以大于当前的 R ，我们需要把 C 更新成 i 的值，也就是 10 ，R 更新成 13。继续下边的循环。
class Solution {
public:
string process(string s) {
int len = s.size();
if (len == 0)return "^$";
string str = "^";
for (int i = 0; i < len; i++)
str = str + "#" + s[i];
str += "#$";
return str;
}
public:
int P[2100];//两倍空间
public:
// 马拉车算法
string longestPalindrome(string s) {
string t = process(s);
int len = t.size();
int C = 0, R = 0;
for (int i = 1; i < len - 1; i++) {
int i_mirror = 2 * C - i;
if (R > i)
P[i] = min(R - i, P[i_mirror]);// 防止超出 R
else P[i] = 0;// 等于 R 的情况
// 碰到之前讲的三种情况时候，需要利用中心扩展法
while (t[i + P[i] + 1] == t[i - P[i] - 1])
P[i]++;
// 判断是否需要更新 R和C
if (i + P[i] > R) {
C = i;
R = i + P[i];
}
}
// 找出 P 的最大值
int ans = 0;
int index = 0;
for (int i = 1; i < len - 1; i++) {
if (P[i] > ans) {
ans = P[i];
index = i;
}
}
int st = (index - ans) / 2; //最开始讲的求原字符串下标
return s.substr(st, ans);
}
};
时间复杂度：for 循环里边套了一层 while 循环，难道不是 O ( n² )，不！其实是 O（n）。我们想象一下整个过程，首先外层有一个 for 循环，所以每个字符会遍历一次，而当我们扩展的时候，每次都是从 R + 1 开始扩展，之后又会更新 R 。所以一些字符会遍历两次，但此时这些字符变到 R 的左边，所以不会遍历第三次了，因为我们每次从 R 的右边开始扩展。综上，每个字符其实最多遍历 2 次，所以依旧是线性的。当然如果字符串长度是 len ，由于扩展了字符串，这里的 n 其实是 2 * len + 3 ，所以是O（2 * len + 3），就是 O（len）。
空间复杂度：O（n）。