LeetCode 132. 分割回文串 II（经典必会）

news2024/11/24 15:03:33

LeetCode 132. 分割回文串 II

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文串。
返回符合要求的最少分割次数。
示例 1：
输入：s = “aab”
输出：1
解释：只需一次分割就可将 s 分割成 [“aa”,“b”] 这样两个回文子串。
示例 2：
输入：s = “a”
输出：0
示例 3：
输入：s = “ab”
输出：1
提示：
1 <= s.length <= 2000
s 仅由小写英文字母组成

动态规划

class Solution:
    def minCut(self, s: str) -> int:
        # dp[i] 表示从第i个字符构成的字符串可以划分成的最少子回文串，字符从0开始计数
        # dp[i] = min(序列S) S中元素为 dp[k] + 1  k from 0 to i-1 且 s[k+1:i]为回文串
        # 每种情况能否成立需要知道+1是否成立，也就是需要知道，右边剩余字符串是否是回文子串
        # 那么如何求的s中任意连续字串是否为回文串呢？

        n = len(s)
        judge = [[False] * n for _ in range(n)]
        for i in range(n - 1):
            g, h = i, i + 1
            while -1 < g < h < n and s[g] == s[h]:
                judge[g][h] = True
                g -= 1
                h += 1
        for i in range(n):
            judge[i][i] = True
            g, h = i - 1, i + 1
            while -1 < g < h < n and s[g] == s[h]:
                judge[g][h] = True
                g -= 1
                h += 1

        dp = [i for i in range(1, n + 1)]
        for i in range(n):
            if judge[0][i]:
                dp[i] = 1

        for i in range(1, n):
            for j in range(i):
                if judge[j + 1][i]:
                    dp[i] = min(dp[i], dp[j] + 1)
        return dp[n - 1] - 1

时间复杂度： $O(n^2)$ 。计算字符串中所有回文串耗时 $O (n)$ 。动态规划计算最少划分次数外层循环次数函数为 $l a yer 1 (n) = n$ ，求面积得耗时 $O(n*n/2)=O(n^2)$ 。
空间复杂度：字符串回文串判定消耗 $O(n^2)$ ，动态规划dp数组消耗 $O (n)$ ，空间复杂度 $O(n^2)$ 。

本题动态规划的思路相对好想，但是关于字符串中所有回文串的判定处理不好会导致时间复杂度过高，导致超时，预处理序列是一种常用的以空间换时间的方法。下面总结一下本题以及一些拓展：

在 $O(n^2)$ 耗时求出字符串中所有连续字符子串是否为回文串。
设dp[i][j]表示从第i个字符到第j个字符构成的字串是否为回文串，字符从0开始计数
最经典的分成两种情况讨论。
若回文串为偶数长度，则最中间两个数往外扩展一定对称，所以长度为n的字符串中连续两个数会有n-1对，对每一对数据进行判断即可
若回文串为奇数长度，则选一个中间数字往两边扩展即可，共有n中选法。

n = len(s)
judge = [[False] * n for _ in range(n)]
for i in range(n - 1):
    g, h = i, i + 1
    while -1 < g < h < n and s[g] == s[h]:
        judge[g][h] = True
        g -= 1
        h += 1
        
for i in range(n):
    judge[i][i] = True
    g, h = i - 1, i + 1
    while -1 < g < h < n and s[g] == s[h]:
        judge[g][h] = True
        g -= 1
        h += 1

而事实上，这里有一种很巧妙地方式可以合并上面两种情况。

奇数和偶数的区别在于，有没有中间值，如果只有一个字符，那么一定是回文串，假设不考虑中间到底有没有字符，那么一个回文串最外面的左右字符一定得相同。假设左边是第i个字符，右边是第j个字符，那么dp[i] == dp[j]，若i到j构成回文串那么i+1到j-1也一定构成，则有
dp[i][j] = dp[i] == dp[j] and dp[i+1][j-1]

不过这里有一些特殊情况：

当i==j时，dp[i+1][j-1]中i+1>j-1导致用到了一个无意义的状态
当i+1==j时，同理，也用到了一个无意义状态
不过巧合的是，当用到无意义状态的时候，只需要看dp[i] == dp[j] 即可，所以这里等效可以把无意义状态全部置为True。

则会有完整状态转移方程。

dp[i][j] =

# 由于在计算dp[i][j]的时候不会用到dp[i][j]本身的值，所以可以同过全部赋值True的方式简化赋初值
# 只需要计算矩阵的一半即可，对角线也无需计算
n = len(s)
judge = [[True] * n for _ in range(n)]
for i in range(n - 1):
    for j in range(i + , n):
        judge[i][j] = judge[i + 1][j - 1] and s[i] == s[j]