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的右边，如下图：

此时我们并不能利用之前的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版本的！