原题链接
题目的意思不过多的赘述,这里先给出三种解法:暴力解,马拉车,一种巧解
暴力解
写一个判断回文的函数,两重循环判断最长子串(这种方法在字符串过长时可能会栈溢出)
class Solution:
def longestPalindrome(self, s: 'str') -> 'str':
if len(s) < 2:
return s
res = s[0]
l = len(s)
for i in range(l):
j = i
while j <= l:
if Solution.isPalindrome(s[i:j]) and len(res) < j - i + 1:
res = s[i:j]
j += 1
i += 1
print("res = ", res)
return res
def isPalindrome(s):
l = len(s)
i, j = 0, l - 1
while i < j:
if s[i] == s[j]:
i += 1
j -= 1
else:
return False
return True
马拉车算法
马拉车算法是解决最长回文子串的经典方法。
步骤为:
- 为了解决奇数和偶数所带来的不便,在字符串的字符之间插入特殊的字符,变成这样:
s = “google”
ss = “#g#o#o#g#l#e#”
为了防止头尾越界,在头尾处加入两个特殊的字符
ss = “$#g#o#o#g#l#e#^” - 引入半径数组p[],其长度与ss相同,具体含义是:p[i]位置上的数代表着以ss[i]为中心的最长回文子串的半径,这个半径长度并不包含i位置,例如,上面的ss数组ss = "#g#o#o#g#l#e#"的p数组为[0, 1,0,1,4,1,0,1,0,1,0,1,0],此算法最为重要的一步就是计算这个半径数组.
第一种方法,遍历挨个将半径逐步的扩张,寻找每个位置的半径,从而计算出整个p数组,这种方法理论上的复杂度为O(n2),但是在实际的运算中效果其实不错,最后会贴上这种方法的代码。
第二种方法,重头戏、
假设p数组已经更新到i位置,也就是说i之前的位置上的p的值已知。所以在i之前最大的回文半径子串是知道的。
我们令现在的最大回文半径的中心点为center,最大回文半径子串的右端为R,左端为L,那么就会有以下的几种情况出现:
情况一:i在R的右边,如下图:
此时我们并不能利用之前的p位置上的值来减少计算量,原因在于i不在现有的最大回文子串的范围内,所以只能暴力扩
情况二:i在R的左端
那么这时又会有三种情形出现,为了以防混淆,这三种情形会用粗体描述。
情形一:
i关于center的对称点i’,其回文半径用黄色的线表示,第一种情形就是黄色线的左端位于L的右侧,如上图所示,这时我们便可以从i+p[i’]的位置向外扩展,
情形二:
黄色线的最左端在L的左边,这种情况可能不太好理解,比如下面的例子:
情形三:
黄色线的最左端在L上。
**其实这三种情况均可以在i的扩展过程中,通过边界条件来进行限制,代码中会有较为详细的描述。
**
class Solution:
def pre_manacher(s):
ss = []
ss.append("#")
for value in s:
ss.append(value)
ss.append("#")
return ss
def back_manacher(ss):
s = ""
for i in range(1, len(ss), 2):
s += ss[i]
return s
def longestPalindrome(self, s):
ss = Solution.pre_manacher(s)
p = []
for i in range(len(ss)):
p.append(0)
C, R = -1, -1
max_L = -1
# max_i = 0
# max_p = 1
i = 0
while i != len(ss):
if R > i:
if p[2*C - i] < R-i:
p[i] = p[2*C - i]
else:
p[i] = R-i
else:
p[i] = 1
while i+p[i] < len(ss) and i-p[i] > -1:
if ss[i+p[i]] == ss[i-p[i]]:
p[i] += 1
else:
break
if i+p[i] > R:
R = i+p[i]
C = i
if max_L < p[i]:
max_L = p[i]
max_i = i
i += 1
print("max_i:",max_i)
print("max_L",max_L)
return Solution.back_manacher(ss[max_i-max_L+1:max_i+max_L])
上面就是马拉车的代码,有时间我会在更新!
下面贴上leetcode上的一位兄弟的代码,很简洁,虽然理论上时间复杂度很高,但是实际运行时只要不是重复数太多的情况下还是可以接受的。
public class Solution {
private int lo, maxLen;
public String longestPalindrome(String s) {
int len = s.length();
if (len < 2)
return s;
for (int i = 0; i < len-1; i++) {
extendPalindrome(s, i, i); //assume odd length, try to extend Palindrome as possible
extendPalindrome(s, i, i+1); //assume even length.
}
return s.substring(lo, lo + maxLen);
}
private void extendPalindrome(String s, int j, int k) {
while (j >= 0 && k < s.length() && s.charAt(j) == s.charAt(k)) {
j--;
k++;
}
if (maxLen < k - j - 1) {
lo = j + 1;
maxLen = k - j - 1;
}
}}
有时间会改成python版本的!