leetcode131. 分割回文串(看得懂的详细分解)

题目:
给定一个字符串 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<List<String>> res = new Solution_131().partition("aab"); System.out.println(res); }*/
}

点赞