Leetcode 131-分割回文串

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

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

题解

图片转载自liweiwei1419
思路分析： 找到所有可能的解，提示我们可以使用「回溯算法」（采用深度优先遍历的方式遍历一棵隐式树结构）。

方法一：回溯算法

回溯算法思考的步骤：

1. 画出树型结构，本题的递归树模型是一棵多叉树；
   

题解可参考代码随想录

其实切割问题类似组合问题，可以利用回溯法截取子串

在递归循环中如何截取子串呢？

• 在for (int i = startIndex; i < s.size(); i++)循环中，我们定义了起始位置startIndex，那么 [startIndex, i] 就是要截取的子串。注意：只有子串为回文子串才能进行截取.首先判断这个子串是不是回文，如果是回文，就加入在vector path中，path用来记录切割过的回文子
• 下一轮的截取是将startIndex置为i+1
• 截取终止条件：startIndex越过了数组长度，即startIndex>=s.length()而不是startIndex>=s.length()-1，说明前面的遍历已经找到了一组符合条件的结果

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

    public void dfs(String s,int startIndex){
        //终止条件,startIndex越过了数组长度，说明此时已经找到了一组分割结果，加入结果集
        if(startIndex>=s.length()){
            res.add(new ArrayList(path));
            return;
        }

        //单层搜索逻辑
        for(int i=startIndex;i<s.length();i++){
            // 获取[startIndex,i]在s中的子串
            String str = s.substring(startIndex, i+1);
            if (isPalindrome(str)) { // 是回文子串
              path.add(str);
            }else{
                continue;
            }
            //注意切割过的位置，不能重复切割，所以传入下一层的起始位置为i + 1
            dfs(s,i+1);
            //回溯
            path.remove(path.size()-1);

        }
    }

    private boolean isPalindrome(String s) {
        for (int i = 0, j = s.length()-1; i < j; i++, j--) {
            if (s.charAt(i) != s.charAt(j)) {
                return false;
            }
        }
        return true;
    }

}

方法二：回溯的优化（使用动态规划得到所有子串是否是回文）

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.List;

public class Solution {

    public List<List<String>> partition(String s) {
        int len = s.length();
        List<List<String>> res = new ArrayList<>();
        if (len == 0) {
            return res;
        }

        char[] charArray = s.toCharArray();
        // 预处理
        // 状态：dp[i][j] 表示 s[i][j] 是否是回文
        boolean[][] dp = new boolean[len][len];
        // 状态转移方程：在 s[i] == s[j] 的时候，dp[i][j] 参考 dp[i + 1][j - 1]
        for (int right = 0; right < len; right++) {
            // 注意：left <= right 取等号表示 1 个字符的时候也需要判断
            for (int left = 0; left <= right; left++) {
                if (charArray[left] == charArray[right] && (right - left <= 2 || dp[left + 1][right - 1])) {
                    dp[left][right] = true;
                }
            }
        }

        Deque<String> stack = new ArrayDeque<>();
        dfs(s, 0, len, dp, stack, res);
        return res;
    }

    private void dfs(String s, int index, int len, boolean[][] dp, Deque<String> path, List<List<String>> res) {
        if (index == len) {
            res.add(new ArrayList<>(path));
            return;
        }

        for (int i = index; i < len; i++) {
            if (dp[index][i]) {
                path.addLast(s.substring(index, i + 1));
                dfs(s, i + 1, len, dp, path, res);
                path.removeLast();
            }
        }
    }
}