小白试水——leetcode腾讯题库-5.最长回文子串（Python解答）

最新推荐文章于 2020-05-19 01:12:14 发布

Ink baboo

最新推荐文章于 2020-05-19 01:12:14 发布

阅读量180

点赞数

分类专栏： Python题库文章标签：小白试水 python

本文链接：https://blog.csdn.net/weixin_42948873/article/details/90153064

版权

Python题库专栏收录该内容

24 篇文章 0 订阅

订阅专栏

题目：5.最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

【笨拙n次循环代码实现】

class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        list = []
        str = ''
        if len(s) == 1:
            return s
        else:
            for i in range(len(s)):
                for j in range(i+1,len(s)):
                    if s[i] == s[j]:
                        n = i
                        for m in range(j,(j+i)//2-1,-1):
                            if s[n] == s[m]:
                                if (n == m) or (n+1 == m):
                                    list.append(s[i:j+1])
                                n += 1
                                if n >= (j+i)//2+1:
                                    break
                            else:
                                break
        if len(list) == 0:
            list.append(s[:1])
        for l in list:
            if (len(l) >= len(str)) or (len(l) == 1):
                str = l
        return str

~~此代码在leetcode上运行【超时】~~

【解析一】

摘要

这篇文章是为中级读者而写的。它介绍了回文，动态规划以及字符串处理。请确保你理解什么是回文。回文是一个正读和反读都相同的字符串，例如，“aba” 是回文，而 “abc” 不是。

解决方案

方法一：最长公共子串

常见错误

有些人会忍不住提出一个快速的解决方案，不幸的是，这个解决方案有缺陷(但是可以很容易地纠正)：

反转 SS，使之变成 S’。找到 S 和 S’ 之间最长的公共子串，这也必然是最长的回文子串。

这似乎是可行的，让我们看看下面的一些例子。

例如，S=“caba”, S′=“abac”：

S 以及 S’ 之间的最长公共子串为 “aba”，恰恰是答案。

让我们尝试一下这个例子：S=“abacdfgdcaba”, S′=“abacdgfdcaba”：

S 以及 S’ 之间的最长公共子串为 “abacd”。显然，这不是回文。

算法

我们可以看到，当 S 的其他部分中存在非回文子串的反向副本时，最长公共子串法就会失败。为了纠正这一点，每当我们找到最长的公共子串的候选项时，都需要检查子串的索引是否与反向子串的原始索引相同。如果相同，那么我们尝试更新目前为止找到的最长回文子串；如果不是，我们就跳过这个候选项并继续寻找下一个候选。

这给我们提供了一个复杂度为 O(n^2) 动态规划解法，它将占用 O(n^2) 的空间（可以改进为使用 O(n) 的空间）。请在这里阅读更多关于最长公共子串的内容。

方法二：暴力法

很明显，暴力法将选出所有子字符串可能的开始和结束位置，并检验它是不是回文。

复杂度分析

时间复杂度：O(n^3)，假设 n 是输入字符串的长度，则 n/2 = (n(n−1))/2 为此类子字符串(不包括字符本身是回文的一般解法)的总数。因为验证每个子字符串需要 O(n) 的时间，所以运行时间复杂度是 O(n^3)。

空间复杂度：O(1)。

方法三：动态规划

为了改进暴力法，我们首先观察如何避免在验证回文时进行不必要的重复计算。考虑 “ababa” 这个示例。如果我们已经知道 “bab” 是回文，那么很明显，“ababa” 一定是回文，因为它的左首字母和右尾字母是相同的。

我们给出 P(i,j) 的定义如下：

$\begin{cases} true, & \text{如果子串 Si…Sj 是回文子串} \\ false, & \text{其它情况} \end{cases}$

因此，

$P (i, j) = (P (i + 1, j - 1) a n d S i = = S j)$
基本示例如下：

$P(i,i)=true\\ P(i,i+1)=(Si ==Si+1)$

这产生了一个直观的动态规划解法，我们首先初始化一字母和二字母的回文，然后找到所有三字母回文，并依此类推…

复杂度分析

时间复杂度：O(n^2)，这里给出我们的运行时间复杂度为 O(n^2) 。

空间复杂度：O(n^2)，该方法使用 O(n^2) 的空间来存储表。

补充练习

你能进一步优化上述解法的空间复杂度吗？

方法四：中心扩展算法

事实上，只需使用恒定的空间，我们就可以在 O(n^2) 的时间内解决这个问题。

我们观察到回文中心的两侧互为镜像。因此，回文可以从它的中心展开，并且只有 2n−1 个这样的中心。

你可能会问，为什么会是 2n−1 个，而不是 n 个中心？原因在于所含字母数为偶数的回文的中心可以处于两字母之间（“abba” 的中心在两个 ‘b’ 之间）。

# java解码
public String longestPalindrome(String s) {
    if (s == null || s.length() < 1) return "";
    int start = 0, end = 0;
    for (int i = 0; i < s.length(); i++) {
        int len1 = expandAroundCenter(s, i, i);
        int len2 = expandAroundCenter(s, i, i + 1);
        int len = Math.max(len1, len2);
        if (len > end - start) {
            start = i - (len - 1) / 2;
            end = i + len / 2;
        }
    }
    return s.substring(start, end + 1);
}

private int expandAroundCenter(String s, int left, int right) {
    int L = left, R = right;
    while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
        L--;
        R++;
    }
    return R - L - 1;
}

复杂度分析

时间复杂度：O(n^2)，由于围绕中心来扩展回文会耗去 O(n) 的时间，所以总的复杂度为 O(n^2)。

空间复杂度：O(1)。

方法五：Manacher 算法

还有一个复杂度为 O(n) 的 Manacher 算法。

【解析二】

思路：

三种思路：

思路 1：

把每个字母当成回文串的中心

这里要考虑两种情况，回文串的长度为奇数或者偶数情况。

代码实现

class Solution:
    def longestPalindrome(self, s: str) -> str:
        n = len(s)
        self.res = ""
        def helper(i,j):
            while i >= 0 and j < n and s[i] == s[j]:
                i -= 1
                j += 1
            if len(self.res) < j - i -1 :
                self.res = s[i+1:j]
        for i in range(n):
            helper(i,i)
            helper(i,i+1)
        return self.res

思路 2：

把每个字母当成回文串的结束

代码实现

class Solution:
    def longestPalindrome(self, s: str) -> str:
        if not s:
            return ""
        max_len = 1
        n = len(s)
        start = 0
        for i in range(1,n):
            even = s[i-max_len:i+1]
            odd = s[i - max_len-1:i+1]
            #print(even,odd)
            if i - max_len - 1 >= 0 and odd == odd[::-1]:
                start = i - max_len - 1
                max_len += 2
            elif i - max_len >=0 and even == even[::-1]:
                start = i - max_len
                max_len += 1
                
        #print(start,max_len)
        return s[start: start+max_len]

思路 3：动态规划

dp[i][j] 表示字符串从 j 到 i 是否是为回文串，即当 s[j] == s[i] 如果 dp[i-1][j+1] 也是回文串，那么字符串从 j 到 i 也是回文串，即 dp[i][j] 为真。

代码实现

class Solution:
    def longestPalindrome(self, s: str) -> str:
        if not s :
            return ""
        res = ""
        n = len(s)
        dp = [[0] * n for _ in range(n)]
        max_len = float("-inf")
        #print(dp)
        for i in range(n):
            for j in range(i,-1,-1):
                if s[i] == s[j] and (i - j < 2 or dp[i-1][j+1]):
                    dp[i][j] = 1
                if dp[i][j] and  max_len < i - j + 1:
                    #print("i,j",i,j)
                    res = s[j:i+1]
                    max_len = i - j + 1
        return res

以上解析部分均为参考学习，请大佬指正，谢谢！！！

Ink baboo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
小白试水——leetcode腾讯题库-5.最长回文子串（Python解答）

小白试水——leetcode腾讯题库-5.最长回文子串（Python解答）题目：5.最长回文子串==【笨拙n次循环代码实现】====【解析一】==摘要解决方案==方法一：最长公共子串==常见错误算法==方法二：暴力法==复杂度分析空间复杂度：O(1)。==方法三：动态规划==复杂度分析==补充练习====方法四：中心扩展算法==复杂度分析==方法五：Manacher 算法====【解析二】==思路...
复制链接

扫一扫