LeetCode题练习与总结：分割回文串Ⅱ--132

一、题目描述

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文串。

返回符合要求的 最少分割次数 。

示例 1：

输入：s = "aab"
输出：1
解释：只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。

示例 2：

输入：s = "a"
输出：0

示例 3：

输入：s = "ab"
输出：1

提示：

• 1 <= s.length <= 2000
• s 仅由小写英文字母组成

二、解题思路

这个问题是典型的动态规划问题。我们可以通过以下步骤来解决这个问题：

1. 预处理：首先，我们创建一个二维数组 isPalindrome 来记录字符串中所有子串是否为回文。这可以通过中心扩展法来实现，从每个字符开始向两边扩展，检查对称位置的字符是否相同。

2. 动态规划：我们使用一个数组 dp，其中 dp[i] 表示字符串的前 i 个字符组成的子串最少可以分割成多少个回文子串。对于每个 i（从 1 到 s.length()），我们检查所有以 i 结尾的子串，如果子串是回文的，那么 dp[i] 可以被更新为 dp[j - 1] + 1，其中 j 是子串的起始位置。

3. 结果：最终 dp[s.length() - 1] 就是答案，表示整个字符串最少可以分割成多少个回文子串。

三、具体代码

public class Solution {
    public int minCut(String s) {
        int n = s.length();
        boolean[][] isPalindrome = new boolean[n][n];
        
        // 预处理，填充 isPalindrome 数组
        for (int i = 0; i < n; i++) {
            isPalindrome[i][i] = true;
        }
        for (int len = 2; len <= n; len++) {
            for (int i = 0; i <= n - len; i++) {
                int j = i + len - 1;
                if (len == 2) {
                    isPalindrome[i][j] = (s.charAt(i) == s.charAt(j));
                } else {
                    isPalindrome[i][j] = (s.charAt(i) == s.charAt(j)) && isPalindrome[i + 1][j - 1];
                }
            }
        }
        
        // 动态规划
        int[] dp = new int[n];
        for (int i = 0; i < n; i++) {
            dp[i] = i; // 最坏情况，每个字符都是一个回文子串
            for (int j = 0; j <= i; j++) {
                if (isPalindrome[j][i]) {
                    if (j == 0) {
                        dp[i] = 0; // 如果整个字符串都是回文的，不需要分割
                    } else {
                        dp[i] = Math.min(dp[i], dp[j - 1] + 1);
                    }
                }
            }
        }
        
        // 结果
        return dp[n - 1];
    }
}

四、时间复杂度和空间复杂度

1. 时间复杂度

• 预处理 isPalindrome 数组：我们需要检查字符串 s 的所有子串是否为回文。这可以通过两重循环完成，外层循环遍历子串的起始位置，内层循环遍历子串的长度。因此，时间复杂度为 O(n^2)，其中 n 是字符串 s 的长度。
• 动态规划 dp 数组：我们再次使用两重循环，外层循环遍历字符串 s 的每个位置，内层循环遍历当前位置之前的所有位置。每次内层循环都会进行一次比较和一次赋值操作，这些操作的时间复杂度为 O(1)。因此，这部分的时间复杂度也是 O(n^2)。
• 综上所述，整个算法的时间复杂度是 O(n^2)。

2. 空间复杂度

• isPalindrome 数组：这是一个二维数组，大小为 n x n，因此空间复杂度为 O(n^2)。
• dp 数组：这是一个一维数组，大小为 n，因此空间复杂度为 O(n)。
• 其他变量：如 i、j、len 等，它们使用的空间可以忽略不计。
• 综上所述，整个算法的空间复杂度是 O(n^2)。

五、总结知识点

1. 动态规划：这是一种用于解决优化问题的算法思想，它将问题分解为相互重叠的子问题，并通过求解子问题的最优解来构建原问题的最优解。在本题中，dp 数组用于存储到当前位置为止的最小切割次数。

2. 回文串的判断：代码中使用了一个二维数组 isPalindrome 来预存储字符串中所有可能的子串是否为回文。这是一个典型的预处理步骤，用于减少在动态规划过程中的重复计算。

3. 中心扩展法：这是一种用于判断回文串的算法，它从每个字符出发，向两边扩展，检查对称位置的字符是否相等。在本题中，中心扩展法用于填充 isPalindrome 数组。

4. 字符串处理：代码中使用了 String 类的 charAt 方法来获取字符串中特定位置的字符，这是 Java 中处理字符串的基本操作。

5. 二维数组和一维数组的使用：isPalindrome 是一个二维布尔数组，用于存储回文信息；dp 是一个一维整型数组，用于存储动态规划过程中的中间结果。这两种数据结构在算法中非常常见。

6. 循环和条件语句：代码中使用了多重循环和条件语句来遍历字符串，并根据不同条件更新数组中的值。这是编程中最基本的结构控制手段。

7. 数学运算：代码中使用了 Math.min 函数来在动态规划过程中取较小值，这是基本的数学运算。

8. 边界条件的处理：在动态规划过程中，代码对边界条件进行了特殊处理，例如当整个字符串都是回文时，不需要切割。

以上就是解决这个问题的详细步骤，希望能够为各位提供启发和帮助。