题目:LeetCode.5 最长回文子串
点击这里来查看题目来源。
给定一个字符串 s
,找到 s
中最长的回文子串。你可以假设 s
的最大长度为 1000。
示例 1:
输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。
示例 2:
输入: "cbbd"
输出: "bb"
解法1:暴力法
定义l
和r
,用于表示回文的左边界和右边界。然后定义一个t
在[l, r]
之间扫描。
代码比较简单,效率较低,这里不写。
时间复杂度:O(n^3)
,空间复杂度:O(1)
。
解法2:DP法求解最长公共子串
我们可以很快的就想到将原有的字符串s
翻转得到fs
,然后得到二者的最长公共子串。需要注意一点,找到了之后还需要判断一下是否是回文串,因为可能会遇上"aacdefcaa"
,其回文串是"aacfedcaa"
,如果比较最长公共子串,得出结果是aac
,不是正确答案,所以需要判断是否是回文。
在判断最长公共子串的时候可以用dp的方法来计算。
代码如下,时间复杂度:O(n^2)
,空间复杂度O(n)
。
class Solution {
public String longestPalindrome(String s) {
char[] cs = s.toCharArray();
char[] fcs = filpChars(cs);
int[] dp = new int[cs.length]; // 仅需要O(n)的空间就可以表示原有的O(n^2)的空间
int pre = 0; // pre => dp[i - 1][j - 1]的状态
int now; //now => dp[i][j]的状态
int maxLen = 0, place = 0;
for (int i = 0; i < cs.length; i++) {
for (int j = 0; j < fcs.length; j++) {
// 前一个状态pre,如果行或列为0,前者状态肯定是0
if (i == 0 || j == 0) pre = 0;
// 计算当前的值
if (cs[i] == fcs[j]) now = pre + 1;
else now = 0;
pre = dp[j]; // 更新pre
dp[j] = now; // 更新dp[j],必须在更新pre之后
// 判断是否是有效的状态
if (now > maxLen && checkPalindrome(fcs, j - now + 1, j)) {
maxLen = now;
place = j;
}
}
}
// 得出最终结果
char[] ans = new char[maxLen];
for (int i = place - maxLen + 1, j = 0; i < place + 1; i++, j++)
ans[j] = fcs[i];
return new String(ans);
}
// 翻转字符串
public char[] filpChars(char[] cs) {
char[] fcs = new char[cs.length];
for (int l = 0, r = cs.length - 1; l < fcs.length; l++, r--)
fcs[l] = cs[r];
return fcs;
}
// 检查是否是回文
public boolean checkPalindrome(char[] c, int l, int r) {
while (l < r) if (c[l++] != c[r--]) return false;
return true;
}
}
解法3:Manacher算法
点击这里来查看英文原文。由于本人能力有限,有可能会出现词不达意的情况,这里贴出原文,大家可以互相参考。
我们现在的目标是改进原有的O(n^2)
时间复杂度。原先的情况中,最糟糕的情况是多个回文相互重叠的输入,例如,输入:"aaaaaaaaa"
和"cabcbabcbabcba"
。实际上,我们可以利用回文的对称属性并避免一些不必要的计算。
首先,我们通过在字母之间插入一个特殊字符'#'
将输入字符串S转换为另一个字符串T,如"abc"
=>"#a#b#c#"
。这样做的原因很快就会清楚。
为了找到最长的回文子串,我们需要在Ti的周围扩展,使得在区间[T(i - d), T(i + d)]
的字符串形成回文。我们可以很清晰的了解,d
是以Ti
为中心的回文的长度。
我们将中间结果存储在数组P中,其中P[i]
等于Ti
处的回文中心的长度。最长的回文子串将是P中的最大元素。
使用上面的例子,我们填充P如下(从左到右):
T = # a # b # a # a # b # a #
P = 0 1 0 3 0 1 6 1 0 3 0 1 0
现在观察一下P,一下子就能够发现最长的回文是"abaaba"
,即P6 = 6
所代表的含义。
如果你观察的足够仔细,你会发现不管是奇数还是偶数的回文长度,在这里都能够得到结果。
现在,想象一下你在回文"abaaba"
的中心画一条想象的垂直线。您是否注意到P中的数字是围绕该中心对称的?不仅如此,尝试另一个回文"aba"
,这些数字(p[i]
的值)也反映出类似的对称属性。这是巧合吗?答案是肯定的,不是。这是有条件的,但无论如何,我们已经有了很大的进步,因为我们可以消除重新计算P[i]
的部分。
让我们继续进行一个稍微复杂的例子,其中有一些重叠的回文,其中S = "babcbabcbaccba"
。
上图的T
是从S = "babcbabcbaccba"
中转换而来。假设您已达到表P
当前的状态。实线垂直线表示回文"abcbabcba"
的中心(C)。两条虚线垂直线分别表示其左(L)和右(R)边缘。当前的索引在i
,它在C周围的镜像索引是i'
。你如何有效的计算P[i]
?
假设我们已经到达i = 13
,我们需要计算P[13]
(由问号?
表示)。我们首先看一下它在回文的中心C周围的镜像索引,即索引i' = 9
。
上面的两条绿色实线表示以i
和i'
为中心的两个回文区域的覆盖区域。我们看看C周围的镜像索引,即索引i'
。P[i'] = P[9] = 1
.很明显P[i]
也必须是1,这是由于回文的中心周围的对称性质。
正如您在上面所看到的,很明显P[i] = P[i'] = 1
,由于围绕回文中心的对称性,它必须是真的。事实上,C之后的所有三个元素都遵循对称性(即P[12] = P[10] = 0
,P[13] = P[9] = 1
,P[14] = P[8] = 0
)。
现在我们在索引i = 15
,它关于C的镜像索引i'= 7
。你认为P[15] = P[7] = 7
吗?
现在我们在索引i = 15
,请问P[i]
的值是多少?如果我们遵循对称属性,P[i]
的值应该与P[i'] = 7
相同。但这是错误的。如果我们在T[15]
处围绕中心扩展,它形成了一个回文"a#b#c#b#a"
,它比我们刚刚提出的p[i'] = 7
要小。为什么?
在索引i
和i'
处围绕中心重叠彩色线。由于C周围的对称属性,绿色实线显示两侧必须匹配的区域。红色实线表示两侧可能不匹配的区域。虚线绿线表示穿过中心的区域。
很明显,由两条实线绿线表示的区域中的两个子串必须完全匹配。中心区域(由绿色虚线表示)也肯定是对称的。仔细注意P[i']
是7并且它一直延伸到回文的左边缘(L)(由实线红线表示),它不再处于在回文的对称性质之下。我们所知道的是P[i] ≥ 5
,为了找到P[i]
的实数值,我们必须通过扩展经过右边缘(R)来进行字符匹配。在这种情况下,由于P[21] ≠ P[1]
,我们得出结论P[i] = 5
。
让我们总结一下这个算法的关键部分如下:
如果 P[i'] ≤ R-i
那么 p[i'] => p[i]
否则 P[i] ≥ P[i']。 // 我们必须扩展经过右边缘(R)才能找到P[i]。
如果你能够完全掌握上述关键伪代码,你就已经获得了这个算法的本质,这也是最难的部分。
最后一部分是确定我们何时应将C的位置与R一起向右移动,这很容易:
如果以i为中心的回文确实扩展到R,我们将C更新为i(这个新回文的中心),并将R扩展到新回文的右边缘。
在每个步骤中,有两种可能性。如果P[i] ≤ R - i
,我们将P[i]
设置为P[i']
,它只需要一步。否则,我们尝试通过从右边缘R开始扩展它来将回文的中心改为i
。扩展R(内部回路)最多总共需要N步,定位和测试每个中心总共需要N步。因此,该算法保证最多完成2 * N步,即线性时间解。
以下是Java的实现代码。时间复杂度:O(n)
,空间复杂度:O(n)
。
class Solution {
public String longestPalindrome(String s) {
String t = preProcess(s);
int[] p = new int[t.length()];
int center = 0, right = 0, ansCenter = 0, ansLen = 0;
for (int i = 1; i < t.length() - 1; i++) {
int iMirror = 2 * center - i; // i的镜像:i` = center - (i - center)
p[i] = (right > i) ? Math.min(right - i, p[iMirror]) : 0;
// 试图扩大以i为中心的回文数据
while (t.charAt(i - 1 - p[i]) == t.charAt(i + 1 + p[i])) p[i]++;
// 如果以i为中心的回文的右边界超过了R,则将新的中心调整为新的回文的中心。
if (i + p[i] > right) {
center = i;
right = i + p[i];
}
//找到P中的最大元素
if (p[i] > ansLen) {
ansLen = p[i];
ansCenter = i;
}
}
return s.substring((ansCenter - ansLen - 1) / 2, (ansCenter + ansLen - 1) / 2);
}
/**
* 将S转换为T.
* 例如,S ="abba",T ="^#a#b#b#a#$"。
* ^和$符号是附加到每一端的标记,以避免边界检查
*/
public String preProcess(String s) {
if (s.length() == 0) return "^$";
char[] cs = new char[s.length() * 2 + 3];
cs[0] = '^';
for (int i = 0; i < s.length(); i++) {
cs[i * 2 + 2] = s.charAt(i);
cs[i * 2 + 1] = '#';
}
cs[cs.length - 2] = '#';
cs[cs.length - 1] = '$';
return new String(cs);
}
}