---
title: 分割回文串dp
description: 分割回文串DP问题，返回的是最小分割次数而不是总方案数
date: 2025-05-07T23:23:00+08:00
slug: 分割回文串dp
# image: helena-hertz-wWZzXlDpMog-unsplash.jpg
categories:
    - 算法题
tags: [
    "动态规划",
    "回文串",
    "算法"
    ]
math: true
---

上文中我们寻找了分割回文串的所有方案。但是如果我们只需要知道最小分割次数，而不需要知道所有具体方案，我们可以使用动态规划来**更高效地**解决这个问题。

首先，我们定义动态规划的状态：

设 $dp[i]$ 表示将字符串 $s$ 从索引 $0$ 到索引 $i$ 的前缀子串 $s[0..i]$ 分割成若干个回文子串所需的**最小切割次数**。我们这里的索引 $i$ 的范围是从 $0$ 到 $n-1$，其中 $n$ 是字符串 $s$ 的长度。

我们的目标是计算 $dp[n-1]$。

接下来，考虑如何从已知状态计算 $dp[i]$。要计算 $s[0..i]$ 的最小切割次数，我们可以考虑最后一次切割（或不切割）。这意味着最后一块回文子串是 $s[j..i]$，其中 $j$ 是这个回文子串的起始索引，$0 \le j \le i$。

如果 $s[j..i]$ 是一个回文子串，那么将 $s[0..i]$ 分割成回文串的一种方案可以是：先将前面的子串 $s[0..j-1]$ 分割好（最优方案需要 $dp[j-1]$ 次切割），然后在索引 $j-1$ 和 $j$ 之间进行一次切割，将 $s[j..i]$ 作为最后一块。

这里需要分情况考虑 $j$ 的值：

1.  如果 $j = 0$：这意味着最后一块回文子串是整个前缀 $s[0..i]$。如果 $s[0..i]$ 本身就是回文串，那么就不需要任何切割，此时的切割次数是 $0$。
2.  如果 $j > 0$：这意味着最后一块回文子串是 $s[j..i]$。前面的子串是 $s[0..j-1]$。将 $s[0..i]$ 分割的次数就是将 $s[0..j-1]$ 分割的最小次数 $dp[j-1]$，再加上索引 $j-1$ 后面这一刀，所以是 $dp[j-1] + 1$ 次切割。

我们要求的是**最小**切割次数 $dp[i]$，所以需要考虑所有可能的起始索引 $j$ ($0 \le j \le i$)，只要 $s[j..i]$ 是回文串，它就提供了一种可能的分割方案。$dp[i]$ 就是所有这些有效方案中切割次数的最小值。

因此，状态转移方程可以写为：

$$dp[i] = \min_{0 \le j \le i \atop s[j..i] \text{ 是回文串}} \{ \text{cost}(j, i) \}$$

其中，$\text{cost}(j, i)$ 是以 $s[j..i]$ 作为最后一块回文子串时的总切割次数，它是一个分段函数：

$$
\begin{cases} 
0 & \text{if } j = 0, \\ 
dp[j-1] + 1 & \text{if } j > 0 
\end{cases}
$$

将 $\text{cost}(j, i)$ 代入方程：

$$dp[i] = \min \left( \begin{cases} 0 & \text{if } 0 \le j \le i \text{ and } s[j..i] \text{ is palindrome and } j = 0, \\ dp[j-1] + 1 & \text{if } 0 \le j \le i \text{ and } s[j..i] \text{ is palindrome and } j > 0 \end{cases} \right)$$

这个分段 min 函数可以简化表达。我们是在所有满足 $s[j..i]$ 是回文串的 $j$ 值中取最小值。如果 $j=0$ 且 $s[0..i]$ 是回文，最小就是 0。否则，如果存在其他 $j>0$ 使得 $s[j..i]$ 是回文，我们就取所有 $dp[j-1]+1$ 中的最小值，然后和可能存在的 0 比较。

更简洁的表达方式是：

对于 $i = 0, 1, \ldots, n-1$:
$$dp[i] = \min_{0 \le j \le i \atop s[j..i] \text{ 是回文串}} \begin{cases} 0 & \text{if } j = 0, \\ dp[j-1] + 1 & \text{if } j > 0 \end{cases}$$

**基本情况：**

$dp[0]$ 的计算：$i=0$。可能的 $j$ 只有 $0$。$s[0..0]$ 是回文串。$j=0$，cost 是 $0$。
$dp[0] = \min(\{0 \mid j=0, s[0..0] \text{ 是回文} \}) = 0$。

在代码中，`dp[i] = i` 的初始化给 `dp[i]` 提供了一个初始上界（最坏情况下，$s[0..i]$ 需要 $i$ 次切割，即每次切割一个字符），然后通过内层循环不断用 `dp[j-1] + 1` 或 0 来尝试更新 `dp[i]` 取到更小值。

**需要注意：**

* 为了使这个 DP 高效，判断 "s[j..i] 是回文串" 需要是 O(1) 操作，这依赖于我们提前进行的 O(n^2) 预处理。
* DP 计算的顺序是 $i$ 从 $0$ 到 $n-1$，确保在计算 $dp[i]$ 时，$dp[j-1]$ (其中 $j-1 < i$) 的值已经被计算出来。

因此我们不能使用上文中的回文串判断方法，而是需要使用动态规划预处理出所有子串是否是回文串。我们建一个二维数组 `isPalindrome`，`isPalindrome[i][j]` 表示 $s[i..j]$ 是否是回文串。根据回文串的性质：

> 一个字符串是回文串，当且仅当它的首尾字符相同，并且去掉首尾，中间的子串也是回文串。

因此我们很自然地分3种情况：

- 单个字符，显然是回文串。
- 两个字符，如果相同，则是回文串。
- 多个字符，如果首尾字符相同，并且去掉首尾后中间的子串也是回文串，则它是回文串。

完整代码：

```java
public static int minCut(String s) {
    int len = s.length();
    // 首先构建回文子串表
    boolean[][] isPalindrome = new boolean[len][len];
    // 单个字符肯定是回文
    for(int i=0;i<len;i++) {
        isPalindrome[i][i] = true;
    }
    // 两个字符是回文，只需首尾相等
    for(int i=0;i<len-1;i++) {
        if(s.charAt(i)==s.charAt(i+1)) isPalindrome[i][i+1]=true;
    }
    // 处理3个及以上字符的子串
    // 是回文，当且仅当首尾相等且去掉首尾仍然是回文
    for(int curlen=3;curlen<=len;curlen++) {
        for(int i=0;i<=len-curlen;i++) {
            int right = i+curlen-1; // 计算右边界
            isPalindrome[i][right] = (s.charAt(i) == s.charAt(right))
                    && isPalindrome[i+1][right-1];
        }
    }
    
    // 然后，动态规划来求最小分割次数
    int[] dp = new int[len];
    // 初始化dp数组
    // 如果是0，不需要分割（单个字符）。其他的取最坏情况，都要分割i次，即每个字符都要分割。
    for(int i=0;i<len;i++) {
        dp[i] = i;
    }
    for(int i=0;i<len;i++) {
        for(int j=0;j<=i;j++) {
            // 注意这里是j<=i，因为单字符串也是回文串，需要正确考虑
            if(isPalindrome[j][i]) {
                if(j==0) dp[i]=0;
                else dp[i]=Math.min(dp[i], dp[j-1]+1);
                // dp[i] 的当前值：它可能是我们为 s[0...i] 设置的初始“最坏情况”值 (i)，或者是之前在内层循环中，因为某个更小的 j' 值 (j' < j) 找到了一个更好的分割方案后更新过的值。它代表了到目前为止，我们已知的将 s[0...i] 分割成回文串的最小切割次数。
            }
        }
    }
    
    return dp[len-1];
}
```