131. Palindrome Partitioning

1 题目理解

输入：字符串s
规则：将字符串s分割，分割后每一个部分都是一个回文串。
输出：所有的分割方式

Example 1:

Input: s = “aab”
Output: [[“a”,“a”,“b”],[“aa”,“b”]]
Example 2:

Input: s = “a”
Output: [[“a”]]

2 回溯

例如s=‘aab’
处理第0个字符a：a是回文吗？是继续处理(第1个字符）
                        aa是回文吗？是，继续处理(第2个字符）
                        aab是回文吗？不是，跳过

处理第1个字符a：a是回文吗？是继续处理(第2个字符）
                        ab是回文吗？不是
…
一直到最后

class Solution {
    private List<List<String>> answer;
    private String s;
    public List<List<String>> partition(String s) {
        answer = new ArrayList<List<String>>();
        this.s = s;
        dfs(0,new ArrayList<String>());
        return answer;
    }
    
    private void dfs(int index,List<String> list){
        if(index>= s.length()){
            answer.add(new ArrayList<String>(list));
            return;
        }
        
        for(int i=index+1;i<=s.length();i++){
            String str = s.substring(index,i);
            if(isPalindrome(str)){
                list.add(str);
                dfs(i,list);
                list.remove(list.size()-1);
            }
        }
    }
    
    private boolean isPalindrome(String s){
        int i = 0,j = s.length()-1;
        while(i<j){
            if(s.charAt(i)!=s.charAt(j)) return false;
            i++;
            j--;
        }
        return true;
    }
}

时间复杂度 O ( n ∗ n ! ) O(n*n!) O(n∗n!)，第一个字符有n种可能，第二个字符有n-1种可能，第三个字符n-2种可能，所以是n!。每次判断是否是回文，时间复杂度O(n)。所以总体时间复杂度 O ( n ∗ n ! ) O(n*n!) O(n∗n!)

3 动态规划

判断是否是回文，可以进一步优化，使用动态规划。这道题目第一次做是2020年5月。还记得当时看到解题答案惊呼原来动态规划初始化还能这么玩！
逻辑是这样的 s=“aab”。
boolean[][] dp，dp[i][j]=true表示下标从i到j的字符串是回文。
对于每个单个字符肯定是回文。所以所有的dp[i][i]=true。
接着处理相邻的，如果s.char(i)=s.charAt(i+1),那么dp[i][i+1]=true。
长度为1，为2的已经处理了。
在这些字符串的基础上左右扩展，如果左右扩展的字符相同，则说明是回文。

class Solution {
    private List<List<String>> answer;
    private String s;
    private boolean[][] dp;
    public List<List<String>> partition(String s) {
        answer = new ArrayList<List<String>>();
        this.s = s;
        int n = s.length();
        dp = new boolean[n][n];
        for(int i=0;i<n;i++){
            dp[i][i] = true;
        }
        for(int i=0;i<n-1;i++){
            if(s.charAt(i)==s.charAt(i+1)){
                dp[i][i+1]=true;
            }
        }
        for(int len = 3;len<=n;len++){
            for(int i=0;i<=n-len;i++){
                int j = len + i - 1;
                if(s.charAt(i) == s.charAt(j) && dp[i+1][j-1]){
                    dp[i][j] = true;
                }
            }
        }
        dfs(0,new ArrayList<String>());
        return answer;
    }
    
    private void dfs(int index,List<String> list){
        if(index>= s.length()){
            answer.add(new ArrayList<String>(list));
            return;
        }
        
        for(int i=index+1;i<=s.length();i++){
            String str = s.substring(index,i);
            if(dp[index][i-1]){
                list.add(str);
                dfs(i,list);
                list.remove(list.size()-1);
            }
        }
    }

}