[leetcode-131]Palindrome Partitioning(java)

最新推荐文章于 2020-09-16 13:30:37 发布

zdavb

最新推荐文章于 2020-09-16 13:30:37 发布

阅读量783

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/zdavb/article/details/47606653

版权

leetcode 专栏收录该内容

243 篇文章 0 订阅

订阅专栏

问题描述：
Given a string s, partition s such that every substring of the partition is a palindrome.

Return all possible palindrome partitioning of s.

For example, given s = “aab”,
Return

[
[“aa”,”b”],
[“a”,”a”,”b”]
]
分析：这种问题第一眼看上去挺吓人的，静下心来慢慢分析就会发现，其实这就是一道深搜的题，起初，我以为DFS会超时，结果没有，时间372ms。
既然能用深搜，那能不能用DP算法呢？可以的，在每个元素的位置存放以当前元素为结尾，所有可能的List集合。
如何考虑该问题呢？DFS的思考过程是逐步趋向终点。当我们得到一个字符串时，如果长度为0，那么就知道已经进行到最后了，直接添加到res中。从字符串的第一个字符开始，判断是否回文，如果是回文，那判断剩余部分是否也是回文。一直递归下去。

DP思想是：f(j) = f(i)+string(i,j)(if str(i,j)为回文，0<=i

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

/**
 * Created by dave on 2015/8/13.
 */
public class PalindromePartitioning {
    private boolean checkPalindrome(String s){
        char[] chars = s.toCharArray();
        if(chars.length<=0)
            return false;
        int start = 0,end = chars.length-1;
        while(start<=end){
            if(chars[start]!=chars[end]){
                return false;
            }
            start++;end--;
        }
        return true;
    }
    public List<List<String>> partition(String s) {
        List<List<String>> res = new LinkedList<>();
        ArrayList<List<List<String>>> map = new ArrayList<>();

        char[] chars = s.toCharArray();
        if(chars.length<=0)
            return res;

        for(int i = 0;i<chars.length;i++){
            List<List<String>> tmp = new LinkedList<>();
            for(int j = i;j>=0;j--){
                String s1 = s.substring(j,i+1);
                if(checkPalindrome(s1)){
                    if(j-1>=0){
                        List<List<String>> prevList = map.get(j-1);
                        for(int k = 0;k<prevList.size();k++){
                            List<String> o = prevList.get(k);
                            List<String> n = new LinkedList<>(o);
                            n.add(s1);
                            tmp.add(new LinkedList<>(n));
                        }
                    }else{
                        List<String> o = new LinkedList<>();
                        o.add(s1);
                        tmp.add(o);
                    }
                }
            }
            map.add(tmp);
        }
        return map.get(chars.length-1);
    }
    void dfs(List<List<String>> res,List<String> tmp,String s){
        int length = s.length();
        if(length==0){
            res.add(new LinkedList<>(tmp));
            return;
        }
        for(int i = 1;i<=length;i++){
            String s1 = s.substring(0,i);
            if(checkPalindrome(s1)){
                tmp.add(s1);
                dfs(res,tmp,s.substring(i));
                tmp.remove(tmp.size()-1);
            }
        }
    }
    public List<List<String>> partition2(String s) {
        List<List<String>> res = new LinkedList<>();
        List<String> tmp = new LinkedList<>();
        dfs(res,tmp,s);
        return res;
    }
    public void test(){
        System.out.println(partition2("aa"));
    }
}