leetcode647. 回文子串python-动态规划篇

题目
给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。回文字符串 是正着读和倒过来读一样的字符串。子字符串 是字符串中的由连续字符组成的一个序列。具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

示例 1：
输入：s = “abc”
输出：3
解释：三个回文子串: “a”, “b”, “c”

示例 2：
输入：s = “aaa”
输出：6
解释：6个回文子串: “a”, “a”, “a”, “aa”, “aa”, “aaa”

提示：
1 <= s.length <= 1000
s 由小写英文字母组成

思路和代码
我的想法一开始不是动态规划。写一个函数判断子串是否是回文子串，是的话累计加1。然后两层for循环对每一个可能的子串进行判断。

class Solution:
    def judge(self,s,left,right):
        while left <= right:
            if s[left] == s[right]:
                left += 1
                right -= 1
            else:
                break
        if len(s)%2 != 0:
            return left-1==right+1
        else:
            return s[left] == s[right]

    def countSubstrings(self, s: str) -> int:
        n = len(s)
        ans = 0
        for i in range(n):
            for j in range(i,n):
                if self.judge(s[i:j+1],0,j-i):
                    ans += 1
        return ans

这段代码调了两次，一次是self.judge(s[i:j+1],0,j-i),一次是judge函数中字符串的长度有奇偶两种情况。

然后回到动态规划上，因为这题之前刷到过，所以想着想着想出来了。首先dp[i][j] 表示的是下标从i到j的子串是否是回文子串，是的话为1 ，否为0。

一开始的时候这个二维数组肯定都初始化为0，还有对角线表示的是单个字符，单个字符肯定是回文串，所以设置为1。

接着想动态转移方程，当s[i]==s[j]的时候，如果j-i < 3，说明是aba类型，或者aa类型，dp[i][j]为1，大于等于3的话，dp[i][j] = dp[i+1]dp[j-1]。

根据状态转移方程确定遍历顺序，i是倒序，j是正序，且j应该比i大。

class Solution:
   def countSubstrings(self, s: str) -> int:
        n = len(s)
        dp = [[0]*n for _ in range(n)]
        for i in range(n):
            dp[i][i] = 1
        for i in range(n-1,-1,-1):
            for j in range(i,n):
                if s[i] == s[j]:
                    if j - i < 3:
                        dp[i][j] = 1
                    else:
                        dp[i][j] = dp[i+1][j-1]
        ans = 0
        for i in range(n):
            ans += dp[i].count(1)
        return ans

代码还可以写的更简洁好看一些。

class Solution:
   def countSubstrings(self, s: str) -> int:
        n = len(s)
        dp = [[0]*n for _ in range(n)]
        res = 0
        for i in range(n-1,-1,-1):
            for j in range(i,n):
                if s[i] == s[j] and  (j-i <= 1 or dp[i+1][j-1]):
                    res += 1
                    dp[i][j] = 1
        return res