leetcode5. Longest Palindromic Substring最长回文子串多种解法-待补充

原题链接
题目的意思不过多的赘述,这里先给出三种解法:暴力解,马拉车,一种巧解
暴力解
写一个判断回文的函数,两重循环判断最长子串(这种方法在字符串过长时可能会栈溢出)

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

马拉车算法
马拉车算法是解决最长回文子串的经典方法。
步骤为:

  1. 为了解决奇数和偶数所带来的不便,在字符串的字符之间插入特殊的字符,变成这样:
    s = “google”
    ss = “#g#o#o#g#l#e#”
    为了防止头尾越界,在头尾处加入两个特殊的字符
    ss = “$#g#o#o#g#l#e#^”
  2. 引入半径数组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的右边,如下图:

leetcode5. Longest Palindromic Substring最长回文子串多种解法-待补充_第1张图片
此时我们并不能利用之前的p位置上的值来减少计算量,原因在于i不在现有的最大回文子串的范围内,所以只能暴力扩
情况二:i在R的左端
那么这时又会有三种情形出现,为了以防混淆,这三种情形会用粗体描述。


情形一:
leetcode5. Longest Palindromic Substring最长回文子串多种解法-待补充_第2张图片
i关于center的对称点i’,其回文半径用黄色的线表示,第一种情形就是黄色线的左端位于L的右侧,如上图所示,这时我们便可以从i+p[i’]的位置向外扩展,
情形二:
leetcode5. Longest Palindromic Substring最长回文子串多种解法-待补充_第3张图片
黄色线的最左端在L的左边,这种情况可能不太好理解,比如下面的例子:
leetcode5. Longest Palindromic Substring最长回文子串多种解法-待补充_第4张图片
情形三:
leetcode5. Longest Palindromic Substring最长回文子串多种解法-待补充_第5张图片
黄色线的最左端在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版本的!

你可能感兴趣的:(leetcod,算)