leetCode每日一题 回文 动态规划

题目

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

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

1.暴力解法
首先我们可以依旧先用比较简单的思路来解决这个问题，就是遍历每一个字符串，在每一个字符上，都找到所有以该字符为首的任意长度的字符串，并判断这个字符串是否为回文串。
我们先创建一个判断回文串的包。

func Palindrome (s string) bool{
    for i:=0; i<len(s)/2;i++{
        if s[i] != s[len(s)-1-i]{
            return false
        }
    }
    return true
}

然后用两个for循环寻找每个字符串并赋值

func longestPalindrome(s string) string {
    var putout string
    max :=0
    for i:=0; i<len(s); i++{

        for j := i+1; j<=len(s); j++{
            temp := s[i: j]
            if Palindrome(temp) && len(temp) >= max{
                max = len(s)
                putout = temp
            }
        }
    }
    return putout
    }

当然，这样的解法时间复杂度过高，由于是三次for循环遍历到每个字符串，执行时间O(n3)过长，所以要简化，可以使用动态规划的算法。

2.动态规划
要了解算法，首先要了解什么是动态规划。动态规划之所以会比一般的暴力解法会好一些，在于它可以记录下此时的状态，并以在此基础上进行下一步的操作。而一般的暴力解法的问题在于要不保存已有的数据，每一次都进行新的一轮判定。
以本题为例，暴力拆解在每次判断的时候都要重新遍历一此所有字符，才能判断出该字符串是否为回文，而动态规划的算法可以记录下此时该字符串为回文，再次判断时只需要调用，而无需重新计算，而且动态规划可以从小的问题开始出发，直到大问题的解决。

动态规划类似于填表格，代表要把n种类型放入到m的容量中去，动态规划的关键在于，能否找准确状态转移的方程。
以本题为例，当一个字符串为回文时，其内在的字符串也为回文，即若有asddsa为回文，则抛去两端，sdds也为回文。
所以就有了转移方程

P(i, j) =( Si == Sj ) && P (i+1, j-1)

不断推导可以得到有最小的回文，即单字符或双字符“bb”，我可以列表推导该题

首先，我们要找见最小回文，首先每个字符都是最小的回文，我们可以先把dp[i ] [ i]，全部设为TURE，然后以此按行按列的将其余表格填好。

我们可以以这个表格为例，从小的回文到大的回文记录，然后判断时可以直接一步步推导，判定这个是否为回文，在回文判断上比暴力拆解建议很多。

以下为代码样例，时间复杂度为O( n2 )

func longestPalindrome(str string) string {
    //把特殊的情况列出
    s := len(str)
    if s<2{
        return str
    }

    dp := make([][] bool, s)

    for i:=0; i<s;i++{
        dp[i] = make([] bool,s)
        dp[i][i] = true
    }
    
    start := 0
    max := 1

    for j :=1; j<s; j++{
        for i:=1;i<s;i++{
            if str[i] == str[j]{
                if j-i<=2{
                    dp[i][j] = true
                } else {
                    dp[i][j]=  dp[i+1][j-1]
                }
            } else {
                dp[i][j] = false
            }
            if dp[i][j] {
                temp := j-i+1
                if temp > max {
                    max = temp
                    start = i
                }
        }
    }

}
return str[start:start+maxlen]
}