5.最长回文子串
动态规划类别的中等难度题,通过率34.3%.
方法一:动态规划
对于一个子串而言,如果它是回文串,并且长度大于 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(即子串长度)的最大值。注意:在状态转移方程中,我们是从长度较短的字符串向长度较长的字符串进行转移的,因此一定要注意动态规划的循环顺序。
public class Solution {
public String longestPalindrome(String s) {
int len = s.length();
if (len < 2) {
return s;
}
int maxLen = 1;
int begin = 0;
// dp[i][j] 表示 s[i..j] 是否是回文串
boolean[][] dp = new boolean[len][len];
// 初始化:所有长度为 1 的子串都是回文串
for (int i = 0; i < len; i++) {
dp[i][i] = true;
}
char[] charArray = s.toCharArray();
// 递推开始
// 先枚举子串长度
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 {
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);
}
}
看一下运行结果,速度中规中矩:
方法二:暴力求解
暴力求解是最容易想到的,要截取字符串的所有子串,然后再判断这些子串中哪些是回文的,最后返回回文子串中最长的即可。
这里我们可以使用两个变量,一个记录最长回文子串开始的位置,一个记录最长回文子串的长度,最后再截取。在截取的时候,如果截取的长度小于等于目前查找到的最长回文子串,我们可以直接跳过,不需要再判断了,因为即使他是回文子串,也不可能是最长的。
public String longestPalindrome(String s) {
if (s.length() < 2)
return s;
int start = 0;
int maxLen = 0;
for (int i = 0; i < s.length() - 1; i++) {
for (int j = i; j < s.length(); j++) {
//截取所有子串,如果截取的子串小于等于之前
//遍历过的最大回文串,直接跳过。因为截取
//的子串即使是回文串也不可能是最大的,所以
//不需要判断
if (j - i < maxLen)
continue;
if (isPalindrome(s, i, j)) {
if (maxLen < j - i + 1) {
start = i;
maxLen = j - i + 1;
}
}
}
}
return s.substring(start, start + maxLen);
}
//判断是否是回文串
private boolean isPalindrome(String s, int start, int end) {
while (start < end) {
if (s.charAt(start++) != s.charAt(end--))
return false;
}
return true;
}
看一下运行结果,如果没有做上述的截取优化,直接超时,只有优化后才出现了结果,但仍然很慢:
方法三:中心扩散法
中心扩散法也很好理解,我们遍历字符串的每一个字符,然后以当前字符为中心往两边扩散,查找最长的回文子串,下面随便举个例子,看一下图片演示:
我们是以每一个字符为中心,往两边扩散,来求最长的回文子串。但忽略了一个问题,回文串的长度不一定都是奇数,也可能是偶数,比如字符串"abba",如果使用上面的方式判断肯定是不对的。
我们来思考这样一个问题,如果是单个字符,我们可以认为他是回文子串,如果是多个字符,并且他们都是相同的,那么他们也是回文串。
所以对于上面的问题,我们以当前字符为中心往两边扩散的时候,先要判断和他挨着的有没有相同的字符,如果有,则直接跳过,来看下代码:
String longestPalindrome(String s) {
//边界条件判断
if (s.length() < 2)
return s;
//start表示最长回文串开始的位置,
//maxLen表示最长回文串的长度
int start = 0, maxLen = 0;
int length = s.length();
for (int i = 0; i < length; ) {
//如果剩余子串长度小于目前查找到的最长回文子串的长度,直接终止循环
// (因为即使他是回文子串,也不是最长的,所以直接终止循环,不再判断)
if (length - i <= maxLen / 2)
break;
int left = i, right = i;
while (right < length - 1 && s.charAt(right + 1) == s.charAt(right))
++right; //过滤掉重复的
//下次在判断的时候从重复的下一个字符开始判断
i = right + 1;
//然后往两边判断,找出回文子串的长度
while (right < length - 1 && left > 0 && s.charAt(right + 1) == s.charAt(left - 1)) {
++right;
--left;
}
//保留最长的
if (right - left + 1 > maxLen) {
start = left;
maxLen = right - left + 1;
}
}
//截取回文子串
return s.substring(start, start + maxLen);
}
这个方法的运行速度就很快,是最佳选择: