131. 分割回文串

• dp[i][j]——字符串[i,j]是否构成一个回文字符串
• dp[i] [i]都为true

自己拆开自己写的

class Solution {
    List<List<String>> result=new ArrayList<>();
    List<String> temp=new ArrayList<>();
    boolean[][] dp ;
    
    public List<List<String>> partition(String s) {
        int len=s.length();
        dp=new boolean[len][len];
        dp=caldp(s);
        dfs(s,0);
        return result;
    }

    //回溯——每次dfs就是加入一个temp；迭代的dfs就是加入另一个temp
    //start:以i为开始的数组，
    void dfs(String s,int start){
        int len=s.length();
        //搜索一个temp时——开始搜索的起始位置已经到了n
        if(start==len){
            result.add(new ArrayList<String>(temp));
            return;
        }
        //这个temp还没搜索完 需要继续搜索
        for(int j=start;j<len;j++){
            if(dp[start][j]){
                temp.add(s.substring(start,j+1));
                dfs(s,j+1);
                temp.remove(temp.size()-1);
            }
        }

    }


    //动态规划：判断回文串，得到dp数组的值
    //dp[i][j]——字符串[i,j]是否构成一个回文字符串，dp[i] [i]都为true
    boolean[][] caldp(String s){
        int len=s.length();
        boolean[][] dp=new boolean[len][len];
        for(int i=0;i<len;i++){
            dp[i][i]=true;
        }
        for(int j=0;j<len;j++){
            for(int i=0;i<j;i++){
                if(s.charAt(i)==s.charAt(j)&&(j-i<=1||dp[i+1][j-1])){
                    dp[i][j]=true;
                }
                else{
                    dp[i][j]=false;
                }
            }
        }
        return dp;
    }

}

题解

class Solution {
    boolean[][] f;
    List<List<String>> ret = new ArrayList<List<String>>();
    List<String> ans = new ArrayList<String>();
    int n;

    public List<List<String>> partition(String s) {
        n = s.length();
        f = new boolean[n][n];
        // 单字母的都为true
        for (int i = 0; i < n; ++i) {
            Arrays.fill(f[i], true);
        }
        // 其他字母组合
        for (int i = n - 1; i >= 0; --i) {
            for (int j = i + 1; j < n; ++j) {
                f[i][j] = (s.charAt(i) == s.charAt(j)) && f[i + 1][j - 1];
            }
        }

        dfs(s, 0);
        return ret;
    }

	//回溯
    public void dfs(String s, int i) {
        if (i == n) {
        	//这边最终全部序列的结果
            ret.add(new ArrayList<String>(ans));
            return;
        }
        for (int j = i; j < n; ++j) {
            if (f[i][j]) {
                ans.add(s.substring(i, j + 1));
                dfs(s, j + 1);
                //回溯操作，撤销上边的操作，这边是只针对一种排列方式的remove比如b,a,a{b,a}是一种{b，aa}又是一种
                ans.remove(ans.size() - 1);
            }
        }
    }
}