leetcode-131-分割回文串-java

题目及测试

package pid131;
/*  分割回文串

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

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

示例:

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


*/

import java.util.List;

public class main {
	
	public static void main(String[] args) {
		String[] testTable = {"aab","232","6574"};
		for (String ito : testTable) {
			test(ito);
		}
	}
		 
	private static void test(String ito) {
		Solution solution = new Solution();
		List> rtn;
		long begin = System.currentTimeMillis();
		System.out.println("ito="+ito);
		System.out.println();
		//开始时打印数组
		
		rtn= solution.partition(ito);//执行程序
		long end = System.currentTimeMillis();	
		
		System.out.println("rtn=" );
		for(int i=0;i

没想出来

解法1（别人的）

1、每一个结点表示剩余没有扫描到的字符串，产生分支是截取了剩余字符串的前缀；

2、产生前缀字符串的时候，判断前缀字符串是否是回文。

    如果前缀字符串是回文，则可以产生分支和结点；
    如果前缀字符串不是回文，则不产生分支和结点，这一步是剪枝操作。

3、在叶子结点是空字符串的时候结算，此时从根结点到叶子结点的路径，就是结果集里的一个结果，使用深度优先遍历，记录下所有可能的结果。

    采用一个路径变量 path 搜索，path 全局使用一个（注意结算的时候，需要生成一个拷贝），因此在递归执行方法结束以后需要回溯，即将递归之前添加进来的元素拿出去；
    path 的操作只在列表的末端，因此合适的数据结构是栈。

验证回文串那里，每一次都得使用“两边夹”的方式验证子串是否是回文子串。

于是思考“用空间换时间”，利用动态规划把结果先算出来，这样就可以以 O(1) 的时间复杂度直接得到一个子串是否是回文。

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

public class Solution2 {

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

        // 预处理
        // 状态：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 (s.charAt(left) == s.charAt(right) && (right - left <= 2 || dp[left + 1][right - 1])) {
                    dp[left][right] = true;
                }
            }
        }

        Stack stack = new Stack<>();
        backtracking(s, 0, len, dp, stack, res);
        return res;
    }

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

        for (int i = start; i < len; i++) {
            
            // 剪枝
            if (!dp[start][i]) {
                continue;
            }
            path.add(s.substring(start, i + 1));
            backtracking(s, i + 1, len, dp, path, res);
            path.pop();
        }
    }
}