Offer 驾到，掘友接招！我正在参与2022春招打卡活动，点击查看活动详情。
一、题目
给你一个字符串 s，找到 s 中最长的回文子串。
示例 1：
输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：
输入：s = "cbbd"
输出："bb"
提示：
- 1 <= s.length <= 1000
- s 仅由数字和英文字母组成
二、我的解答
首先明白回文的定义：回文的意思是正着念和倒着念一样，如：上海自来水来自海上。
简单点说，就是对称性，aa或者aba这种对称形式，当然单个字符a也是符合回文要求。
第一次解答：
public String longestPalindrome(String s) {
int rkFinal = 0,lkFinal = 0;
int ans=0;
//从第一个字符开始比较,首先检查，后续是否出现相同字符。如果出现，就判断这段字符子串是否对称
for (int lk = 0; lk < s.length(); lk++) {
//因为单字符，自己也是个对称的回文子串，所以这里从rk=lk开始
for (int rk = lk; rk < s.length(); rk++) {
if (s.charAt(lk)==s.charAt(rk)){
//判断是否为回文子串，回文子串即对称，aba,abba这样子
boolean result=true;
for (int childLK = lk; childLK <=(rk-lk)/2+lk; childLK++) {
if (s.charAt(childLK)!=s.charAt(rk-(childLK-lk))){
result=false;
}
}
if (result){
// 判断当前回文子串和上一个回文子串哪一个大
if (ans<=rk-lk){
ans =rk-lk;
rkFinal=rk;
lkFinal=lk;
}
}
}
}
}
return s.substring(lkFinal,rkFinal+1);
}
报错：超出时间限制
第二次解答：
之所以会出现超出时间的限制，主要是因为没考虑某些节点跳出循环，做了很多无用功。第二次解答进行了优化。（但是时间复杂度其实还是O(n^3)）
先说一下之前的思路：
1、取一个字符x，和后面所有字符比较；
2、如果找到与之相等的字符x'，就判断从x开始到x'结束的这个子串是否是一个回文子串（回文子串的意思就是是否对称，比如aabb,aba）；
3、如果对称，就判断这个子串的长度是否比上一个查找出来的子串的长度长（默认初始为0），如果是，就记录长度为ans，并记住子串下标；
4、输出结果
优化在哪里呢？
一个是在判断是否为回文子串的时候，如果有一个不相等，就应该直接跳出遍历了，因为接下来的比对没有意义；
另一个优化是，第一次解答是取一个字符x，和其之后的字符顺序进行比对。第二次解答是取一个字符，和其之后的字符逆序进行比对。这样做的好处是什么呢？
逆序比对，一旦比对成功并判断为回文子串，那么它必定是关于当前字符x的最长的回文子串，就可以跳出当前关于x字符的查找，左指针向右移动一个。这样就避免了顺序挨个判断的无用功。
public static String longestPalindrome(String s) {
//从第一个字符开始比较,首先检查，后续是否出现相同字符。如果出现，就判断这段字符子串是否对称
int rkFinal = 0, lkFinal = 0;
int ans = 0;
//遍历字符串里的字符
for (int lk = 0; lk < s.length(); lk++) {
//字符x的回文子串们的查找
for (int rk = s.length() - 1; rk >lk; rk--) {
if (s.charAt(lk) == s.charAt(rk)) {
//判断是否为回文子串，回文子串即对称，aba,abba这样子
boolean result = true;
for (int childLK = lk; childLK <= (rk - lk) / 2 + lk; childLK++) {
if (s.charAt(childLK) != s.charAt(rk - (childLK - lk))) {
result = false;
break;
}
}
if (result) {
// 判断当前回文子串和上一个回文子串哪一个大
if (ans <= rk - lk) {
ans = rk - lk;
rkFinal = rk;
lkFinal = lk;
}
break;
}
}
}
}
// 判断当前回文子串和上一个回文子串哪一个大
if (rkFinal!=0||lkFinal!=0){
return s.substring(lkFinal, rkFinal + 1);
}
return s.charAt(0)+"";
}
三、系统解答
每次看官方解答，都是一脸懵逼，然后恍然大悟。然后百思不得其解，为何别人能想起来这么干，我却想不起来。
方法一：动态规划
思路与算法
对于一个子串而言，如果它是回文串，并且长度大于 2，那么将它首尾的两个字母去除之后，它仍然是个回文串。例如对于字符串“ababa”，如果我们已经知道“bab” 是回文串，那么“ababa” 一定是回文串，这是因为它的首尾两个字母都是 “a”。
根据这样的思路，我们就可以用动态规划的方法解决本题。我们用 P(i,j) 表示字符串 s 的第 i 到 j个字母组成的串（下文表示成 s[i:j]）是否为回文串：
这里的「其它情况」包含两种可能性：
- s[i, j]本身不是一个回文串；
- i>j，此时 s[i, j]本身不合法。
那么我们就可以写出动态规划的状态转移方程：
也就是说，只有 s[i+1:j-1] 是回文串，并且 s 的第 i 和 j 个字母相同时，s[i:j] 才会是回文串。
上文的所有讨论是建立在子串长度大于 2的前提之上的，我们还需要考虑动态规划中的边界条件，即子串的长度为 1 或 2。对于长度为 1 的子串，它显然是个回文串；对于长度为 2 的子串，只要它的两个字母相同，它就是一个回文串。因此我们就可以写出动态规划的边界条件：
根据这个思路，我们就可以完成动态规划了，最终的答案即为所有P(i,j)=true 中 j−i+1（即子串长度）的最大值。注意：在状态转移方程中，我们是从长度较短的字符串向长度较长的字符串进行转移的，因此一定要注意动态规划的循环顺序。（从长度为2的，往后递推）
public static String longestPalindrome2(String s) {
int len = s.length();
if (len < 2) {
return s;
}
int maxLen = 1;
int begin = 0;
// dp[i][j] 表示 s[i..j] 是否是回文串，即下标从i到j的子串是否是回文串
boolean[][] dp = new boolean[len][len];
// 初始化：所有长度为 1 的子串都是回文串（下标从i到i，一个字符的子串）
for (int i = 0; i < len; i++) {
dp[i][i] = true;
}
char[] charArray = s.toCharArray();
// 递推开始
// 先枚举子串长度L,Length,先从子串长度为2开始判断（之所以先把最小长度的求出来，是为了后面递归的时候找到结果）
for (int L = 2; L <= len; L++) {
// 枚举左边界，左边界的上限设置可以宽松一些
for (int i = 0; i < len; i++) {
// 由 L 和 i 可以确定右边界，即 j - i + 1 = L 得
int j = L + i - 1;
// 如果右边界越界，就可以退出当前循环
if (j >= len) {
break;
}
//只要子串中，出现一次不对称，那么该子串就不是回文子串
if (charArray[i] != charArray[j]) {
dp[i][j] = false;
} else {
//小于3的意思是，i和j之间最多只有一个字符，此时又因为charArray[i] = charArray[j]，也就是aba,aa的形式，必定是回文子串
if (j - i < 3) {
dp[i][j] = true;
} else {
//递归，一个子串，最外面的字符相等，他是否是回文子串？就要看他里面是否也相等
dp[i][j] = dp[i + 1][j - 1];
}
}
// 只要 dp[i][L] == true 成立，就表示子串 s[i..L] 是回文，此时记录回文长度和起始位置
if (dp[i][j] && j - i + 1 > maxLen) {
maxLen = j - i + 1;
begin = i;
}
}
}
return s.substring(begin, begin + maxLen);
}
时间复杂度：O(n^2)，其中 n 是字符串的长度。动态规划的状态总数为 O(n^2)，对于每个状态，我们需要转移的时间为 O(1)。
空间复杂度：O(n^2)，即存储动态规划状态需要的空间。
方法二：中心扩展算法
思路与算法
我们仔细观察一下方法一中的状态转移方程：
找出其中的状态转移链：
可以发现，所有的状态在转移的时候的可能性都是唯一的。也就是说，我们可以从每一种边界情况开始「扩展」，也可以得出所有的状态对应的答案。
边界情况即为子串长度为 1 或 2 的情况。我们枚举每一种边界情况，并从对应的子串开始不断地向两边扩展。如果两边的字母相同，我们就可以继续扩展，例如从 P(i+1,j−1) 扩展到 P(i,j)；如果两边的字母不同，我们就可以停止扩展，因为在这之后的子串都不能是回文串了。
聪明的读者此时应该可以发现，「边界情况」对应的子串实际上就是我们「扩展」出的回文串的「回文中心」。
方法二的本质即为：我们枚举所有的「回文中心」并尝试「扩展」，直到无法扩展为止，此时的回文串长度即为此「回文中心」下的最长回文串长度。我们对所有的长度求出最大值，即可得到最终的答案。
public String longestPalindrome(String s) {
if (s == null || s.length() < 1) {
return "";
}
int start = 0, end = 0;
for (int i = 0; i < s.length(); i++) {
//假定中心点为char(i)，向两边扩展，即aia这种形式
int len1 = expandAroundCenter(s, i, i);
//假定为中心点为char(i),char(i+1)，向两边扩展,即char(i)=char(i+1)，aiia这种形式
int len2 = expandAroundCenter(s, i, i + 1);
//比较出这两种情况下最大的一个，记录长度
int len = Math.max(len1, len2);
//比较当前长度len和之前长度end - start的大小，并记录
if (len > end - start) {
start = i - (len - 1) / 2;
end = i + len / 2;
}
}
return s.substring(start, end + 1);
}
public static int expandAroundCenter(String s, int left, int right) {
while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
--left;
++right;
}
return right - left - 1;
}
复杂度分析
时间复杂度：O(n^2)，其中 n 是字符串的长度。长度为 1和 2的回文中心分别有 n 和 n−1 个，每个回文中心最多会向外扩展 O(n) 次。
空间复杂度：O(1)。
方法三：Manacher 算法
还有一个复杂度为 O(n) 的 Manacher 算法。然而本算法十分复杂，一般不作为面试内容。这里给出，仅供有兴趣的同学挑战自己。
为了表述方便，我们定义一个新概念臂长，表示中心扩展算法向外扩展的长度。如果一个位置的最大回文字符串长度为 2 * length + 1 ，其臂长为 length。
感兴趣的自己跳转查看：Manacher算法
