剑指 Offer II 086. 分割回文子字符串（131. 分割回文串）（中等 回溯 字符串 动态规划）

剑指 Offer II 086. 分割回文子字符串（131. 分割回文串）

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

回文串 是正着读和反着读都一样的字符串。

示例 1：

输入：s = “aab”
输出：[[“a”,“a”,“b”],[“aa”,“b”]]
示例 2：

输入：s = “a”
输出：[[“a”]]

提示：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-partitioning
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析

参考官方题解：
https://leetcode-cn.com/problems/palindrome-partitioning/solution/fen-ge-hui-wen-chuan-by-leetcode-solutio-6jkv/
需要注意，回文串利用动态规划思想记录，回溯切割字符串用substring方法，索引的开头为传入回溯方法的index，结尾是遍历的索引 i + 1。
后面贴一个剑指offer题目的答案（list转二维数组）
小 tips：首先，用 LinkedList 在数据量大时删除很慢，并且转换为String[][]数组用到的 get() 方法也比较慢，所以不要用 LinkedList，用 ArrayList 替换之，这里的删除方法 path.removeLast() 替换为 path.remove(path.size() - 1)；另外，list 转二维数组内循环用遍历即可，用 ans[i] = res.get(i).toArray() 代替循环会耗时更多

题解（Java）

class Solution {
    List<List<String>> ans = new LinkedList<>();
    List<String> path = new LinkedList<>();
    boolean[][] f;
    int n;

    public List<List<String>> partition(String s) {
        n = s.length();
        f = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            Arrays.fill(f[i], true);
        }
        for (int i = n - 1; i >= 0; i--) {
            for (int j = i + 1; j < n; j++) {
                //f[i + 1][j - 1] 是用来判断中间字符串是不是回文，如果两头相同、中间回文那就是回文
                f[i][j] = (s.charAt(i) == s.charAt(j)) && f[i + 1][j - 1];
            }
        }
        backTracking(s, 0);
        return ans;
    }

    private void backTracking(String s, int index) {
        if (index == n) {
            ans.add(new ArrayList<String>(path));
            return;
        }
        for (int i = index; i < n; i++) {
            if (f[index][i]) {
                path.add(s.substring(index, i + 1));
                backTracking(s, i + 1);
                path.remove(path.size() - 1);
            }
        }
    }
}

class Solution {
    public String[][] partition(String s) {
        int n = s.length();
        char[] arr = s.toCharArray();
        boolean[][] dp = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                dp[i][j] = true;
            }
        }
        for (int i = n - 1; i >= 0; i--) {
            for (int j = i + 1; j < n; j++) {
                dp[i][j] = (arr[i] == arr[j] && dp[i + 1][j - 1]);
            }
        }
        List<List<String>> res = new ArrayList<>();
        List<String> path = new ArrayList<>();
        dfs(res, path, s, n, dp, 0);
        
        // List<List<String>> 转 String[][]
        String[][] ans = new String[res.size()][];
        for (int i = 0; i < res.size(); i++) {
            ans[i] = new String[res.get(i).size()];
            for (int j = 0; j < ans[i].length; j++) {
                ans[i][j] = res.get(i).get(j);
            }
        }
        return ans;
    }

    public void dfs(List<List<String>> res, List<String> path, String s, int n, boolean[][] dp, int pos) {
        if (pos == n) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = pos; i < n; i++) {
            if (dp[pos][i]) {
                path.add(s.substring(pos, i + 1));
                dfs(res, path, s, n, dp, i + 1);
                path.remove(path.size() - 1);
            }
        }
    }
}