【算法】分割回文串【动态规划】【回溯】

题目：

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

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

示例 1：

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

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

1 <= s.length <= 16
s 仅由小写英文字母组成
Related Topics
字符串
动态规划
回溯

题解

首先看到“最大’、”最小“、”最少“、”所有结果“等题目，可以首先考虑用动态规划去解决。这个题目可以看到需要返回s中所有可能得分割方案，我们首先想到可以用动态规划去解决。然后我们继续看题，他说要讲s分割成一些子串，使每个子串都是回文串，这个时候我们可以简单用动态规划的思路去思考下。s = “aab”, 设置初始start = 0; end = i ++;找到子回文串之后start=end; s.substring(start, end)当确认第一个子串是回文串的时候，我们的第一个子串可能是"a"/“aa”,然后根据第一个已经确定的子串，推理需要确定第二个子字符串是否为回文串，第二个子字符串可能是"a"/“b”，确定完第二个字符串的时候可能start 任然小于s.length，也就是s还没被分割完。这个时候就需要就需要回溯进行处理，保证start 或 end 每次变动截取到的子回文串，可以找到所有子回文串的可能。

由此推到动态转移方程为:

字符串总长度为len, 子串start 起始位置，子串end结束位置

dp[start, len] = dp[start, end] + dp[len - end, len]

start 为固定值的时候end是不固定的可能会有多种情况，比如aab,start = 0, end可能为1和2，所以这个时候就需要用到回溯来处理。

代码

/**
  * 判断字符串是否为回文字符串
  *
  * @param s 回文串
  * @return
  */
public static boolean isPalindrome(String s) {

    String s1 = s.toLowerCase().trim();
    String realStr = s1.replaceAll("[^a-z|0-9]", ""); // 不用太在意，做其他算法的时候要过滤特殊字符，我直接把方法抄过来了，可以自己写这个判断是否为回文的方法
    if (s.length() <= 1) {
        return true;
    }
    int i = 0, j = realStr.length() - 1;
    while (true) {
        if (i >= j) {
            break;
        }

        if (realStr.charAt(i) != realStr.charAt(j)) {
            return false;
        }

        i ++;
        j --;
    }
    return true;
}

 /**
  * 给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。
  * 回文串 是正着读和反着读都一样的字符串。
  *
  * 示例 1：
  *
  * 输入：s = "aab"
  * 输出：[["a","a","b"],["aa","b"]]
  * 示例 2：
  *
  * 输入：s = "a"
  * 输出：[["a"]]
  * 提示：
  *
  * 1 <= s.length <= 16
  * s 仅由小写英文字母组成
  * Related Topics
  * 字符串
  * 动态规划
  * 回溯
  */
public List<List<String>> partition(String s) {
    List<List<String>> lists = new ArrayList<>(); // 结果集
    Map<String, Boolean> isPalindromeMap = new HashMap<>(); // 是否为回文缓存
    partitionRecursive(isPalindromeMap, 0, 1, s, new ArrayList<>(), lists); // 递归回溯处理
    return lists;
}

/**
 * 分割橙子穿，递归函数
 * 
 * @param isPalindromeMap 回文字符串记录，缓存
 * @param start 回文子串起始位置
 * @param end 回文子串结束位置
 * @param s 原始父字符串
 * @param list 其中一组结果集
 * @param lists 结果集
 */
public void partitionRecursive(Map<String, Boolean> isPalindromeMap,
                               int start,
                               int end,
                               String s,
                               List<String> list,
                               List<List<String>> lists) {

    if (start == s.length()) { // 如果start = s.length 说明字符串已经分割完了，直接add到list，否则可能是字符串未分割完，此次分割不存在回文串
        lists.add(list);
    }

    if (start > s.length() || end > s.length()) { // 递归开口
        return;
    }

    String temp = s.substring(start, end); // 截取子串
    Boolean aBoolean = isPalindromeMap.get(temp);
    if ((aBoolean != null && aBoolean) || isPalindrome(temp)) { // 先从缓存中判断是否存在回文，不是再计算是否回文
        isPalindromeMap.put(temp, true);
        List<String> tempList = new ArrayList<>(list);
        tempList.add(temp);
        partitionRecursive(isPalindromeMap, end, end + 1, s, tempList, lists); // 找到回文串继续往下走
    }
    partitionRecursive(isPalindromeMap, start, end + 1, s, list, lists); // 回溯
}

总结

实现可能不是最完美的方案，只是一种思路，大家可以参考。