分割回文子字符串

分割回文子字符串

给定一个字符串 s ，请将 s 分割成一些子串，使每个子串都是 回文串 ，返回 s 所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。
示例 1：
输入：s = “google”
输出：[[“g”,“o”,“o”,“g”,“l”,“e”],[“g”,“oo”,“g”,“l”,“e”],[“goog”,“l”,“e”]]

首先使用动态规划得到所有子串是否是回文子串的情况,这里参考这个动态规划判断回文子串,然后思路就是DFS+回溯即可.先判断当前子串是否是回文子串,如果是就DFS继续往后进行,然后回溯找到所有的情况即可!

public String[][] partition(String s) {
        int n = s.length();
        List<List<String>> ans = new ArrayList<>();
        List<String> res = new ArrayList<>();
        //dp[i][j]表示字符串中[i,j]区间内的子串是否是回文串
        boolean[][] dp = new boolean[n][n];

        //初始化
        for (int i = 0; i < n; i++) Arrays.fill(dp[i], true);

        //从最尾部开始进行每一处回文串的判断  这个要好好理解
        for (int i = n - 1; i >= 0; i--) {
            for (int j = i + 1; j < n; j++) {
                dp[i][j] = dp[i + 1][j - 1] && (s.charAt(i) == s.charAt(j));
            }
        }

        DFS(s, dp, ans, res, 0);

        String[][] out = new String[ans.size()][];
        for (int i = 0; i < ans.size(); i++) {
            out[i] = new String[ans.get(i).size()];
            for (int j = 0; j < ans.get(i).size(); j++) {
                out[i][j] = ans.get(i).get(j);
            }
        }
        return out;
    }


    public void DFS(String s, boolean[][] dp, List<List<String>> ans, List<String> res, int index) {
        if (index == s.length()) {
            ans.add(new ArrayList<>(res));
            return;
        }

        for (int i = index; i < s.length(); i++) {
            if (dp[index][i]) {//如果是回文子串 那么就DFS向下继续寻找
                res.add(s.substring(index, i + 1));
                DFS(s, dp, ans, res, i + 1);
                res.remove(res.size() - 1);//回溯
            }
        }
    }