力扣：分割回文串

动态规划预处理+回溯：

class Solution {
    public List<List<String>> partition(String s) {
        int n = s.length();
        //用于预处理，判断每个子串是否是回文串
        boolean[][] dp = new boolean[n][n];

        // 初始化：单个字符都是回文
        for (int i = 0; i < n; i++) {
            dp[i][i] = true;
        }

        for (int i = 1; i < n; i++) {
            for (int j = 0; j < i; j++) {
                if (s.charAt(i) == s.charAt(j)) {
                    if (i - j + 1 <= 3) {
                        // 子串长度为1或2或3时必定是回文串
                        dp[j][i] = true;
                    } else {
                        // 根据上一个状态推导当前状态
                        dp[j][i] = dp[j + 1][i - 1];
                    }
                } else {
                    dp[j][i] = false;
                }
            }
        }

        List<List<String>> list = new ArrayList<>();
        dfs(list, new ArrayList<>(), dp, s, 0, n);
        return list;
    }

    // 递归函数，生成所有可能的分割方案
    void dfs(List<List<String>> list, List<String> stringList, boolean[][] dp, String s, int begin, int n) {
        if (begin == n) {
            // 当达到字符串末尾，将当前分割方案添加到结果列表中
            list.add(new ArrayList<>(stringList));
            return;
        }
        for (int end = begin; end < n; end++) {
            if (dp[begin][end]) {
                // 如果当前子串是回文串，则将其添加到当前分割方案中
                stringList.add(s.substring(begin, end + 1));
                dfs(list, stringList, dp, s, end + 1, n);
                // 回溯，移除最后一个添加的子串，继续尝试其他分割方案
                stringList.remove(stringList.size() - 1);
            }
        }
    }
}