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<List<String>> 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<rtn.size();i++){			
			for(int j=0;j<rtn.get(i).size();j++){				
				System.out.print(rtn.get(i).get(j)+" ");	
			}
			System.out.println();
		}
		System.out.println();
		System.out.println("耗时：" + (end - begin) + "ms");
		System.out.println("-------------------");
	}

}

没想出来

解法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<List<String>> partition(String s) {
        int len = s.length();
        List<List<String>> 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<String> stack = new Stack<>();
        backtracking(s, 0, len, dp, stack, res);
        return res;
    }

    private void backtracking(String s, int start, int len, boolean[][] dp, Stack<String> path, List<List<String>> 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();
        }
    }
}

解法2（成功，24ms，较慢）

public class Solution {
	
	public List<List<String>> result=new ArrayList<>();
	
	public HashMap<String, Boolean> mapPalindrome=new HashMap<>();
	
	public List<List<String>> partition(String s) {
		List<String> list = new ArrayList<String>();
        backTrace(s, 0, list);
		return result;
    }
	
	private void backTrace(String s,int begin,List<String> list){
		if(begin == s.length()) {
			result.add(new ArrayList<String>(list));
		}
		for(int i=begin;i<s.length();i++) {
			if(isPalindrome(s, begin, i)) {
				list.add(s.substring(begin, i + 1));
				backTrace(s, i + 1, list);
				list.remove(list.size() - 1);
			}
		}
	}
	
	private boolean isPalindrome(String s,int begin,int end){
		String key = begin + "-" + end;
		if(mapPalindrome.containsKey(key)){
			return mapPalindrome.get(key);
		}
		boolean result=true;
		int length=end - begin + 1;
		s = s.substring(begin, end + 1);
		if(length==0||length==1){
			result=true;
		}else{
			int i=0;
			int j=length-1;
			while(i<=j){
				if(s.charAt(i)!=s.charAt(j)){
					result=false;
					break;
				}
				i++;
				j--;
			}
		}
		mapPalindrome.put(s, result);
		return result;
	}

}