#4_力扣打卡第四天(5)

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
示例 2：

输入：s = "cbbd"
输出："bb"
示例 3：

输入：s = "a"
输出："a"
示例 4：

输入：s = "ac"
输出："a"

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-palindromic-substring
 

思路：

遇到这道题，我一开始的想法是：
首先要有一个函数来判断输入的字符串是否是回文，

再利用移动窗口，逐渐增大窗口长度，通过窗口移动的方式遍历，从而得到答案。

以下为代码。

def judge(l: str):#返回0，即不是回文，返回1，是回文
    length = len(l)
    mid = length // 2
    i = 0  # 记录起点
    while i != mid:
        if l[i] == l[-(i + 1)]:
            i = 1 + i
            continue
        else:
            return 0
    return 1
def longestPalindrome(s:str):
    # 排除特殊情况
    if len(s)==0:
        return 0
    if len(s) == 1:
        return s
    if len(s) == 2:
        if s[0] == s[1]:
            return s
        else:
            return s[0]

    l = 1   # l记录最长字串长度
    mem = s[0]#mem记录最长字串
    for i in range(2, len(s)+1):  # i为窗口长度
        for j in range(0, len(s) - i+1):  # j为窗口起点
            k = s[j:j + i]
            if judge(k):
                mem = k
                l = i
                break
    return mem
s="zbkksfgesmfyuedjxdtknclymgskfjduhfocipzjqnmvcodjlvlagmhokqfeudickyeoobmkerjdeloxfbauryanltprloaeboavxzltgcurgbtgtpygpjizoopwmwjixaowppdvkferupefhwombszifyliidrxpxgcpbfzqtxdfiwfmtgvjiccrigwljrlvhaegvbitngckdnsfcnqlgykwjmsifcttcbeummaoidrrhkxmxctugcrlpbiolzqnjtwhzreruglrdvzioewcgvjjwfyqmhupusktptvfpcqxkvpbrlzchtacmlzgeejnvjzzhcegwtwqhimwooflzeiomeqyrnaeiquolmsunqrgffkpljewyritkivdrfnovbatdstypzsmbjdrromcqexnmjcuqpjzzjpqucjmnxeqcmorrdjbmszpytsdtabvonfrdviktirywejlpkffgrqnusmlouqieanryqemoiezlfoowmihqwtwgechzzjvnjeegzlmcathczlrbpvkxqcpfvtptksupuhmqyfwjjvgcweoizvdrlgurerzhwtjnqzloibplrcgutcxmxkhrrdioammuebcttcfismjwkyglqncfsndkcgntibvgeahvlrjlwgirccijvgtmfwifdxtqzfbpcgxpxrdiilyfizsbmowhfepurefkvdppwoaxijwmwpoozijpgyptgtbgrucgtlzxvaobeaolrptlnayruabfxoledjrekmbooeykciduefqkohmgalvljdocvmnqjzpicofhudjfksgmylcnktdxjdeuyfmsegfskkbz"
print(longestPalindrome(s))

结果：

 没错，最后用例为：

最后执行的输入：

"zbkksfgesmfyuedjxdtknclymgskfjduhfocipzjqnmvcodjlvlagmhokqfeudickyeoobmkerjdeloxfbauryanltprloaeboavxzltgcurgbtgtpygpjizoopwmwjixaowppdvkferupefhwombszifyliidrxpxgcpbfzqtxdfiwfmtgvjiccrigwljrlvhaegvbitngckdnsfcnqlgykwjmsifcttcbeummaoidrrhkxmxctugcrlpbiolzqnjtwhzreruglrdvzioewcgvjjwfyqmhupusktptvfpcqxkvpbrlzchtacmlzgeejnvjzzhcegwtwqhimwooflzeiomeqyrnaeiquolmsunqrgffkpljewyritkivdrfnovbatdstypzsmbjdrromcqexnmjcuqpjzzjpqucjmnxeqcmorrdjbmszpytsdtabvonfrdviktirywejlpkffgrqnusmlouqieanryqemoiezlfoowmihqwtwgechzzjvnjeegzlmcathczlrbpvkxqcpfvtptksupuhmqyfwjjvgcweoizvdrlgurerzhwtjnqzloibplrcgutcxmxkhrrdioammuebcttcfismjwkyglqncfsndkcgntibvgeahvlrjlwgirccijvgtmfwifdxtqzfbpcgxpxrdiilyfizsbmowhfepurefkvdppwoaxijwmwpoozijpgyptgtbgrucgtlzxvaobeaolrptlnayruabfxoledjrekmbooeykciduefqkohmgalvljdocvmnqjzpicofhudjfksgmylcnktdxjdeuyfmsegfskkbz"

结果超时了，时间复杂度为：o（n的三次方）。

遇事不决，只能参考参考评论了。

参考：力扣评论。

中心扩散法：

class Solution:
    def longestPalindrome(self, s: str) -> str:
        n, m = 0, 0#n,m保存最长子序列的长度
        for i in range(len(s)):
            left, right = i, i
            while left >= 0 and s[left] == s[i]: left -= 1
            while right < len(s) and s[right] == s[i]: right += 1
            while left >= 0 and right < len(s) and s[left] == s[right]:
                left -= 1
                right += 1
            if m - n + 1 < right - left - 1:
                n, m = left + 1, right - 1
        return s[n:m+1]

看了万能的评论才知道，遍历时间复杂度太高，本质还是没有抓住回文的特点，即对称，可以通过找中心点的方式逐步扩展，若长度为偶数，采用这种方法也可。

动态规划：

class Solution:
    def longestPalindrome(self, s: str) -> str:
        dp = [[False] * len(s) for _ in s]

        left, right = 0, 0
        for i in range(len(dp)-1, -1, -1):
            for j in range(i, len(dp)):
                if i == j:
                    dp[i][j] = True
                elif i == j - 1:
                    dp[i][j] = s[i] == s[j]
                else:
                    dp[i][j] = s[i] == s[j] and dp[i+1][j-1]
                if dp[i][j] and right - left < j - i:
                    left, right = i, j
        return s[left:right+1]

在中心扩散法的基础上，进而引申出了动态规划（我理解的，没有啥特别的先后顺序），在理解了中心扩散法后，发现可以利用上一个扩散的点来继续拓展，即通过保存上一步的数据，可以在上一步的基础上继续观察是否能拓展，从而找到最大的区间。