leetcode131. 分割回文串 Java （看得懂的详细分解）

题目：
给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

示例:

输入: "aab"
输出:
[
  ["aa","b"],
  ["a","a","b"]
]

对于要求列出所有情况的，我们通常直接考虑使用回溯算法。需要在回溯的过程中加上一些小的技巧，例如通过条件排除一些情况等，来优化算法的时间复杂度。

对于本题，我们尝试这样思考：要得到所有都是回文串的分割方案，我们就需要对字符串进行分割，至于需要分割几下，我们不知道。那么首先第一次分割的地方可以是第一个字符串之后，也可以是第二第三。。。个字符串之后，第二次分割是从上次分割之后的字符串开始，同样长度可以是一二三。。。个字符串。这样就能够得出我们分割几下取决于什么时候碰到最后边界。

这样一想，这就是经典的回溯算法，最后的结果需要若干步骤才能得到，每一步又有很多个选择，如果深入进去发现这条路不是最后的结果，那就退回来继续尝试其他的路径。

解决本题的时候有一个关键技巧，就是在判断子串是否是回文串的时候，保存之前判断的情况，这样就能够优化时间复杂度。

下面的代码时间复杂度超过了100%的提交，代码中添加了详细注释，结合上面的应该可以充分理解。

import java.util.ArrayList;
import java.util.List;

/**
 * 回溯算法
 * 时间复杂度：3ms，100%
 * 空间复杂度：38.6MB，97.10%
 */
public class Solution_131 {
    /*
    用来保存从任意一位置至任意一位置的子串是否是回文串，类似于动态规划中保存之前的状态来减小时间复杂度
    不同之处在于这里的状态并没有发生转移，所以不算是动态规划与回溯算法的结合
    这一步是优化时间复杂度的关键
     */
    int[][] dp;

    public List<List<String>> partition(String s) {
        List<List<String>> res = new ArrayList<>();
        if (null == s || s.length() == 0) {
            return res;
        }
        int length = s.length();
        /*
        它是一个二维矩阵，有三种状态值：
        0表示之前还没有计算过
        1表示从下表i到j的子串是回文串
        2表示不是回文串
        我们只用到了数组的右上半部分
        当然这里也可以使用char数组，空间复杂度更低
         */
        dp = new int[length][length];
        //初始化，单个字符的肯定是回文串
        for (int i = 0; i < length; i++) {
            dp[i][i] = 1;
        }

        ArrayList<String> templist = new ArrayList<>();
        helper(res, templist, s, length, 0);
        return res;
    }

    /**
     * 回溯算法
     *
     * @param res      结果集
     * @param templist 中间list
     * @param s        字符串
     * @param length   字符串长度
     * @param index    从当前位置向后组合判断
     */
    private void helper(List<List<String>> res, ArrayList<String> templist, String s, int length, int index) {
    	//走到这一步就表示走到了最后，添加到结果集
        if (index == length) {
            res.add(new ArrayList<>(templist));//一定要重新new一个对象，templist可以得到重用
        }
        //走到某一步有若干的选择继续走下一步
        for (int i = index; i < length; i++) {
            if (isPalindrome(s, index, i)) {
                templist.add(s.substring(index, i + 1));
                helper(res, templist, s, length, i + 1);
                templist.remove(templist.size() - 1);//回溯算法中回退一定要记得这一步
            }
        }
    }

    //判断是否是回文串，这里首先需要到保存的状态中查看是否之前已经有了，优化时间复杂度
    private boolean isPalindrome(String s, int from, int to) {
        if (dp[from][to] == 1) {
            return true;
        } else if (dp[from][to] == 2) {
            return false;
        } else {
            for (int i = from, j = to; i < j; i++, j--) {
                if (s.charAt(i) != s.charAt(j)) {
                    dp[from][to] = 2;
                    return false;
                }
            }
            dp[from][to] = 1;
            return true;
        }
    }

/*    public static void main(String[] args) {
        List> res = new Solution_131().partition("aab");
        System.out.println(res);
    }*/
}