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

一、题目描述

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

示例 2：

输入：s = "a"
输出：[["a"]]

提示：

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

二、解题思路

这个问题是一个典型的回溯问题，我们需要找到所有可能的分割方案，使得每个子串都是回文串。我们可以使用回溯算法来解决这个问题。解题思路如下：

1. 回文判断：首先，我们需要一个辅助函数来判断一个字符串是否是回文串。这个函数可以通过比较字符串的首尾字符来判断，如果首尾字符相同，则继续判断内部子串，直到字符串被完全判断或者发现不是回文串。

2. 回溯搜索：我们使用回溯算法来搜索所有可能的分割方案。从字符串的第一个字符开始，我们尝试将其作为第一个回文串，然后递归地在剩余的字符串上继续寻找回文串。每次找到一个回文串，我们就将其加入到当前的分割方案中，并递归地处理剩余的字符串。

3. 构建结果：当递归搜索到达字符串的末尾时，说明我们找到了一个有效的分割方案，我们将这个方案加入到结果列表中。

4. 剪枝：在搜索过程中，如果当前分割的子串不是回文串，我们可以直接返回，不需要继续搜索这个分支。

三、具体代码

import java.util.ArrayList;
import java.util.List;

public class Solution {
    public List<List<String>> partition(String s) {
        List<List<String>> result = new ArrayList<>();
        backtrack(result, new ArrayList<>(), s, 0);
        return result;
    }

    private void backtrack(List<List<String>> result, List<String> tempList, String s, int start) {
        if (start == s.length()) {
            result.add(new ArrayList<>(tempList));
            return;
        }
        for (int i = start; i < s.length(); i++) {
            if (isPalindrome(s, start, i)) {
                tempList.add(s.substring(start, i + 1));
                backtrack(result, tempList, s, i + 1);
                tempList.remove(tempList.size() - 1);
            }
        }
    }

    private boolean isPalindrome(String s, int low, int high) {
        while (low < high) {
            if (s.charAt(low++) != s.charAt(high--)) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Solution solution = new Solution();
        List<List<String>> partitions = solution.partition("aab");
        for (List<String> partition : partitions) {
            System.out.println(partition);
        }
    }
}

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

1. 时间复杂度

• isPalindrome函数：这个函数的时间复杂度是 O(n)，其中 n 是字符串的长度。在最坏的情况下，它需要比较字符串的一半字符来确定它是否是回文。

• backtrack函数：这个函数对于字符串 s 的每个位置 i，都会调用 isPalindrome 函数来检查以 i 结尾的子字符串是否是回文。因此，backtrack 函数的时间复杂度取决于 isPalindrome 函数的调用次数。

• partition函数：这个函数初始化结果列表，并开始回溯过程。它的时间复杂度取决于 backtrack 函数的时间复杂度。

• 综上所述，整个算法的时间复杂度是由 backtrack 函数决定的。在最坏的情况下，backtrack 函数会被调用 O(2^n) 次（每次调用 isPalindrome 函数的时间复杂度是 O(n)），因此总的时间复杂度是 O(n * 2^n)。

2. 空间复杂度

• 结果列表 result：这个列表存储了所有可能的分割方案。在最坏的情况下，如果字符串 s 的每个字符都是一个回文串，那么每个字符都会被分割成一个单独的子串，这将导致结果列表的长度为 O(n)。

• 临时列表 tempList：这个列表存储了当前的分割方案。它的最大长度也是 O(n)，因为它可能包含字符串 s 的所有字符作为单独的子串。

• 递归栈：递归调用会使用调用栈。在最坏的情况下，递归的深度可以达到 O(n)，因此递归栈的空间复杂度也是 O(n)。

• 综上所述，整个算法的空间复杂度是由结果列表、临时列表和递归栈的空间复杂度共同决定的。因此，总的空间复杂度是 O(n)。

注意：这里的时间复杂度和空间复杂度分析是基于最坏情况下的估计。在实际应用中，由于回文串的分布和长度不同，实际的时间和空间复杂度可能会有所不同。

五、总结知识点

1. 回溯算法：这是一种通过探索所有可能的候选解来找出所有的解的算法。如果候选解被确认不是一个解（或者至少不是最后一个解），回溯算法会通过在上一步进行一些变化丢弃该解，即回溯并且再次尝试。

2. 递归：这是一种编程技巧，函数自己调用自己。在这个代码中，backtrack 函数就是递归的，它调用自己来探索所有可能的分割。

3. 字符串处理：代码中使用了 substring 方法来从原字符串中提取子字符串。这是 Java 中处理字符串的常用方法。

4. 列表（List）的使用：代码中使用了 ArrayList 来存储结果和临时的分割方案。这是 Java 集合框架中的一部分，用于存储动态的元素序列。

5. 动态添加和删除元素：在 backtrack 函数中，使用了 add 和 remove 方法来动态地添加和删除临时列表 tempList 中的元素。这是对列表进行操作的基本技巧。

6. 函数参数的传递：代码中多次使用了列表作为函数参数。在 Java 中，对象（包括列表）是通过引用传递的，这意味着在函数内部对参数的修改会影响到原始对象。

7. 字符串比较：在 isPalindrome 函数中，通过比较字符串的首尾字符来判断字符串是否为回文。这是对字符串进行操作的基本技巧。

8. 循环和条件语句：代码中使用了 for 循环和 if 条件语句来控制程序的逻辑流程。

9. 布尔运算：在 isPalindrome 函数中，使用了布尔运算来返回一个布尔值，表示字符串是否为回文。

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