647. 回文子串

题目来源：力扣（LeetCode）https://leetcode-cn.com/problems/palindromic-substrings python

题目

给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。算法

具备不一样开始位置或结束位置的子串，即便是由相同的字符组成，也会被视做不一样的子串。数组

示例 1：bash

输入："abc"
输出：3
解释：三个回文子串: "a", "b", "c"

示例 2：ui

输入："aaa"
输出：6
解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa"

提示：.net

输入的字符串长度不会超过 1000 。

解题思路

思路：动态规划

先看题目，题目要求在给定的字符串中，求得字符串中有多少个回文子串。其中说起，不一样开始或结束位置的子串，即使相同也视为不一样子串。code

其实看完题目，咱们想到最直接的想法就是，先枚举字符的组合，判断这些字符组合成的子串是不是回文串便可。blog

如今咱们来看看，用这种直接的方法代码实现：leetcode

class Solution:
    def countSubstrings(self, s: str) -> int:
        def is_palindrome(string):
            """判断传入字符串是不是回文串
            """
            left = 0
            right = len(string) - 1
            while left < right:
                if string[left] != string[right]:
                    return False
                left += 1
                right -= 1

            return True

        # 计数
        count = 0
        # 枚举字符组合
        for i in range(len(s)):
            for j in range(i, len(s)):
                # 判断字符组合是不是回文串
                # 如果计数 +1，不然跳过
                sub_string = s[i:j+1]
                if is_palindrome(sub_string):
                    count += 1
        return count

上面的方法中，假设字符串长度为 n，咱们枚举全部子串须要 $O(n^2)$ 的时间，而判断子串是否回文串须要 $O(S)$ 的时间，S 是子串的长度，因此整个算法的时间是 $O(n^3)$。字符串

这里用 Python 执行结果超时，也侧面说明思路是可行的。这里执行超时的缘由如上所述，是由于频繁对字符串切片以及判断子串是不是回文串。

下面咱们看看使用动态规划的思路如何解决。

动态规划

假设，s[i...j](i...j 表示这个区间内的字符包含 i、j)是回文串。那么 s[i-1...j+1] 只有在 s[i-1] == s[j+1] 的状况下，才是回文串。

状态定义

如今设 dp[i][j] 表示 s[i...j] 是不是回文串。

状态转移方程

接下来，咱们分析一下，子串是回文串成立的状况：

若是 i == j，那么表示是单字符，单字符也是回文串；
若是 s[i] == s[j] 且 i+1=j（或i=j-1），那么这里表示两个字符且相同，那么一样是回文串；
若是 dp[i+1][j-1] == True，也就是 s[i+1...j-1] 是回文串时，若 s[i]==s[j]，此时 dp[i][j] 一样也是回文串。

咱们能够看到，第2、三种状况是能够合并在一块儿的。

当 s[i]==s[j]，只要 i==j-1 或者 dp[i+1][j-1]==True 其中一个成立，dp[i][j] 都为 True，s[i...j] 是回文串。公式以下：

$dp[i][j] = True, \qquad if , (s[i] == s[j]) , and , (i==j-1 , or , dp[i+1][j-1])$

再看第一种状况，咱们发现，其实 i==j 时，s[i] == s[j] 也是成立的，只是此时 i=j-0，。

那么这里再将第一种状况跟上面合并，也就是 i >= j - 1 或者 i - j >= -1 时，公式以下：

$dp[i][j] = True, \qquad if , (s[i] == s[j]) , and , (i-j>=-1 , or , dp[i+1][j-1])$

复杂度分析：

时间复杂度： $O(n^2)$
空间复杂度： $O(n^2)$， dp 数组的开销。

还有 中心扩散法，这个方法可以将空间复杂度下降为常数时间复杂度 $O(1)$。这里在官方题解有给出详细内容，有兴趣的能够从下面连接入口进入了解。

https://leetcode-cn.com/problems/palindromic-substrings/solution/hui-wen-zi-chuan-by-leetcode-solution/

具体的代码实现以下。

代码实现

class Solution:
    def countSubstrings(self, s: str) -> int:
        # 计数
        count = 0
        n = len(s)
        # 定义 dp 数组，初始化为 False
        dp = [[False] * n for _ in range(n)]
        # 咱们从右往左遍历，填充 dp 数组
        for i in range(n-1, -1, -1):
            for j in range(i, n):
                # 根据文章得出的状态转移方程
                if s[i]==s[j] and (i-j>=-1 or dp[i+1][j-1]):
                    dp[i][j] = True
                    count += 1

        return count

实现结果

欢迎关注

公众号【书所集录】

LeetCode 647. 回文子串 | Python