leetcode刷题_day4_（动态规划）_code5（最长回文子串）

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

示例 1：

输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
示例 2：

输入: “cbbd”
输出: “bb”

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-palindromic-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解答：
1.
首先可以想到最暴力的解法，寻找所有子字符串，然后一一进行判断是否为回文，然后获取最大长度的字符串之一即可。
代码：

def longestPalindrome(s) :
    max_len=0
    max_sub=''
    for i in range(len(s)):
        for j in range(i,len(s)):
            new_s = s[i:j+1]
            print(new_s,'#')
            res,leng_current,sub_current = huiwen(new_s)
            if res:
                if leng_current > max_len:
                    max_len = leng_current
                    max_sub = sub_current
    return max_sub



def huiwen(s2):
    leng = len(s2)
    mid = (leng-1)//2
    if leng%2==0:
        for index in range(0,mid+1):
            if s2[index] == s2[leng-1-index]:
                continue
            else:
                return False,0,0
        return True,leng,s2
    else:
        for index in range(0,mid):
            if s2[index] == s2[leng-1-index]:
                continue
            else:
                return False,0,0
        return True,leng,s2


x = longestPalindrome('')
print(x)
#girl_str = "aba"

#for index in range(0,3):

#    print (girl_str[index])

代码好写，但是时间复杂度为O(N^3)。

参考解析方法之一为 将字符串倒序以后，寻找两个字符串里相同的子字符串。同时要避免出现非回文，要限定序号一致。代码有空补上。

采用动态规划进行解题。简而言之 动态规划类似于一个 函数 Y = af(x-1) +bf(x-2)。从小范围内有解的结果引申推导到大范围的结果。
题目中，奇数项均可由奇数后续判断两边是否相等来得到新的回文串；同理偶数项一样。
(1). 为了迭代出来最大范围结果，可以先求长度为1的回文串（任意单元素项）以及长度为2的回文串（任意相等紧挨项）.
(2). 循环迭代条件：迭代时，进行两边的判定，如果相等则进入下一个迭代，直到没有相等的为止。（没有可返回空）
(3). 临界条件：进行迭代生长，临界点为，奇偶后续的Y函数中不再有新的字符串。添加判定条件。
代码：
(4). 边界条件：字符串长度为0 1 2的时候的判定。迭代时双边是否存在的判定等。

def longestPalindrome(s) :
    leng = len(s)
    list_even = []
    list_odd = []
    if s == '':
        return ''
    elif leng<=2:
        if s[0]==s[1]:
            return s
        else:
            return s[0]
    else:
        for i in range(leng):
            list_odd.append([i,i,1])
        for i in range(leng-1):
            if s[i] == s[i+1]:
                list_even.append([i,i+1,2])
    while len(list_odd) !=0 or len(list_even) !=0:
        current_odd = list_odd
        current_even = list_even
        #print(current_odd,'#')
        #print(current_even,'##')
        list_odd,list_even = operation_array(list_odd,list_even,s)
        if len(list_odd) ==0 and len(list_even) ==0:
            if len(current_odd) ==0:
                start = current_even[0][0]
                end = current_even[0][1]
                return s[start:end+1]
            elif len(current_even)==0:
                start = current_odd[0][0]
                end = current_odd[0][1]
                return s[start:end + 1]
            else:
                start = current_even[0][0]
                end = current_even[0][1]
                return s[start:end + 1]



def operation_array(arr_odd,arr_even,s):
    #print(arr_odd,'#2')
    #print(arr_even,'##2')
    odd_len=len(arr_odd)
    even_len=len(arr_even)
    new_odd = []
    new_even = []
    print(odd_len)

    if odd_len != 0:
        for i in range(odd_len):
            left = arr_odd[i][0]
            right = arr_odd[i][1]
            #print(right,right+1)

            print(left,right, '###test###')
            #m = 0>=0 and 4<=4 and s[0]==s[4]
            #print(m)
            if left-1 >=0 and right+1 <= len(s)-1 and s[left-1] == s[right+1]:
                new_odd.append([left-1,right+1,arr_odd[i][2]+2])
                print(new_odd)



    if even_len !=0:
        for i in range(even_len):
            left = arr_even[i][0]
            right = arr_even[i][1]


            #print(left-1 >=0 and right+1 <= odd_len-1 and s[left-1] == s[right+1])
            if left-1 >=0 and right+1 <= len(s)-1 and s[left-1] == s[right+1]:
                new_even.append([left-1,right+1,arr_even[i][2]+2])
    #print(new_odd,new_even,'##########')

    return new_odd,new_even

    #for i in range(len(arr_odd)):


x = longestPalindrome("abcba")
print(x)

arr1=[['a', 0, 0], ['b', 1, 1], ['b', 2, 2], ['c', 3, 3], ['a', 4, 4], ['s', 5, 5], ['c', 6, 6], ['v', 7, 7], ['v', 8, 8]]
arr2=[['ab', 0, 1], ['bb', 1, 2], ['bc', 2, 3], ['ca', 3, 4], ['as', 4, 5], ['sc', 5, 6], ['cv', 6, 7], ['vv', 7, 8]]
a = arr1

依然可以优化，对字符串进行奇迭代以及偶迭代。已经AC，暂不做修改。