1. 题目描述
[229] 求众数‖
给你一个字符串 s，找到 s 中最长的回文子串。
示例 1：
输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：
输入：s = "cbbd"
输出："bb"
示例 3：
输入：s = "a"
输出："a"
示例 4：
输入：s = "ac"
输出："a"
提示：
1 <= s.length <= 1000
s 仅由数字和英文字母（大写和/或小写）组成
Related Topics 字符串 动态规划
2. 思路分析
一开始我思考着，直接使用循环调用的方式，验证出最长的回文串，但是失败了，如果字符串的长度太长的话，会超时（method1）。
可重用性还是很有必要的，因此，我想着定义一个数组，来记录字符串的不同位置之间的字串是否是回文串。这样的话，已经得出的结果就可以反复利用，整理一下思路（method2）
- 定义一个二维数组，长度跟字符串长度一致
- 初始化二维数组，两个下标一致相当于只有一个字符串，肯定为 true
- 嵌套循环（参考解法，这里可以从两个方向循环 方法2 和 3 ），遍历字符串，找出所有字串以及最长的回文子串
- 判断回文串的一个方式，如果头尾字符相同，中间没有其他字符或者只有一个字符，如
aba,那说明就是回文串，如果中间的字符大于1，那么可以掐头去尾，再对掐头去尾后的字符串做判断。（动态规划的一个关键）
- 判断回文串的一个方式，如果头尾字符相同，中间没有其他字符或者只有一个字符，如
- 在嵌套循环，遍历字符串的同时，也可以对出现的回文子串进行长度比较，最后留下来的，就是最终的结果
对于这道题，看题解的时候还学到了一种新的思路，中心扩散法
中心扩散法的思路是：遍历每一个索引，以这个索引为中心，利用“回文串”中心对称的特点，往两边扩散，看最多能扩散多远。下面就列举写法（method4）
3. AC代码
public class No5 {
public String longestPalindrome(String s) {
return method1(s);
}
// ----- method1 begin -----
/**
* Time Limit Exceeded
* 遇到超长的字符串会超时
*/
private String method1(String s) {
if (s.length() < 2) return s;
return getLongestPalindrome(s, "");
}
private String getLongestPalindrome(String s, String re) {
if ("".equals(s)) return s;
for (int i = 1; i <= s.length(); i++) {
if (isPalidrome(s.substring(0, i))) {
if (s.substring(0, i).length() >= re.length()) {
re = s.substring(0, i);
}
String rightLongestPalindrome = getLongestPalindrome(s.substring(i), re);
if (re.length() < rightLongestPalindrome.length()) {
re = rightLongestPalindrome;
}
}
}
return re;
}
private boolean isPalidrome(String s) {
int left = 0;
int right = s.length() - 1;
while (left < right) {
if (s.charAt(left) != s.charAt(right)) return false;
left++;
right--;
}
return true;
}
// ----- method1 end -----
// ----- method2 start -----
/**
* 构造一个标志字符串下标位置是否为回文数的二维数组,
*
* 执行耗时:176 ms,击败了53.57% 的Java用户
* 内存消耗:43.1 MB,击败了26.04% 的Java用户
*/
public String method2(String s) {
// 特殊判断
int len = s.length();
if (len < 2) {
return s;
}
// dp[i][j] 表示 s[i, j] 是否是回文串
boolean[][] dp = new boolean[len][len];
char[] charArray = s.toCharArray();
// 初始化
for (int i = 0; i < len; i++) {
dp[i][i] = true;
}
// 这里细节只记录下标和长度，减少了每次出现回文串 subString 去比较的开销
int maxLen = 1;
int begin = 0;
for (int j = 1; j < s.length(); j++) {
for (int i = 0; i < j; i++) {
if (charArray[i] != charArray[j]) {
dp[i][j] = false;
} else {
if (j - i < 3) {
// 中间无间隔或只有一个字符，都符合回文规律
dp[i][j] = true;
} else {
// 如果一个字符串是回文串，掐头去尾后的字符串也是回文串
dp[i][j] = dp[i + 1][j - 1];
}
}
if (dp[i][j]) {
int nowLen = j - i + 1;
if (nowLen > maxLen) {
maxLen = nowLen;
begin = i;
}
}
}
}
return s.substring(begin, begin + maxLen);
}
// ----- method2 end -----
// ----- method3 start -----
/**
* 我copy的，类似method2
*
* 执行耗时:285 ms,击败了35.31% 的Java用户
* 内存消耗:43.1 MB,击败了25.49% 的Java用户
*/
public String method3(String s) {
int len = s.length();
if (len < 2) {
return s;
}
boolean[][] dp = new boolean[len][len];
for (int i = 0; i < len; i++) {
Arrays.fill(dp[i], false);
}
// 初始化
for (int i = 0; i < len; i++) {
dp[i][i] = true;
}
char[] charArray = s.toCharArray();
int maxLen = 1;
int start = 0;
for (int j = 1; j < len; j++) {
// 类似method2, i 正着写、倒过来写都行，因为子串都有参考值
for (int i = j - 1; i >= 0; i--) {
if (charArray[i] == charArray[j]) {
if (j - i < 3) {
dp[i][j] = true;
} else {
dp[i][j] = dp[i + 1][j - 1];
}
} else {
dp[i][j] = false;
}
// 只要 dp[i][j] == true 成立，就表示子串 s[i, j] 是回文，此时记录回文长度和起始位置
if (dp[i][j]) {
int curLen = j - i + 1;
if (curLen > maxLen) {
maxLen = curLen;
start = i;
}
}
}
}
return s.substring(start, start + maxLen);
}
// ----- method3 end -----
// ----- method4 start -----
/**
*
* 执行耗时:39 ms,击败了73.37% 的Java用户
* 内存消耗:39.2 MB,击败了50.65% 的Java用户
* @param s
* @return
*/
private String method4(String s) {
int len = s.length();
if (len < 2) {
return s;
}
int maxLen = 1;
String res = s.substring(0, 1);
// 中心位置枚举到 len - 2 即可
for (int i = 0; i < len - 1; i++) {
// 对应中心位
String oddStr = centerSpread(s, i, i);
// 对应相邻两个字符相同的情况
String evenStr = centerSpread(s, i, i + 1);
String maxLenStr = oddStr.length() > evenStr.length() ? oddStr : evenStr;
if (maxLenStr.length() > maxLen) {
maxLen = maxLenStr.length();
res = maxLenStr;
}
}
return res;
}
private String centerSpread(String s, int left, int right) {
// left = right 的时候，此时回文中心是一个字符，回文串的长度是奇数
// right = left + 1 的时候，此时回文中心是一个空隙，回文串的长度是偶数
int len = s.length();
int i = left;
int j = right;
while (i >= 0 && j < len) {
if (s.charAt(i) == s.charAt(j)) {
i--;
j++;
} else {
break;
}
}
// 这里要小心，跳出 while 循环时，恰好满足 s.charAt(i) != s.charAt(j)，因此不能取 i，不能取 j
return s.substring(i + 1, j);
}
// ----- method4 end -----
}
4. 总结
动态规划的思想还是要多了解一下（对应method2、method3）：
- 思考状态
- 回文串的判断、二维数组的对应下标位置
- 思考状态转移方程
- 当前下标的字符相同 s[i] == s[j]
- 回文串的判断可以放到 字符串掐头去尾的子串判断
dp[i + 1][j - 1] == true ?
- 思考初始化
- dp[i] [i] =true
要多多做题，巩固感觉
很多内容参考自leetCode题解-动态规划、中心扩散、Manacher 算法,十分详细，推荐观看
本文正在参与「掘金 2021 春招闯关活动」, 点击查看 活动详情
