Leetcode 131/132 分割回文DFS回溯与动态规划。

显然，直接DFS回溯

class Solution {
public:
    vector<vector<string>> res;
    vector<vector<string>> partition(string s) {
        vector<string> path;
        dfs(s,0,path);
        return res;
    }

    void dfs(string s, int index, vector<string> &path){
        if(index>=s.size()){
            res.push_back(path);
            return;
        }
        for(int i=index;i<s.size();i++){
            if(check(s.substr(index,i-index+1))){
                path.push_back(s.substr(index,i-index+1));
                dfs(s,i+1,path);
                path.pop_back();
            }
        }
    }

    bool check(string s){
        int left = 0, right = s.size()-1;
        while(left<right){
            if(s[left++]!=s[right--]) return false;
        }
        return true;
    }
};

 

这个题目就比较困难，直接DFS时间复杂度指数量级

动态规划，dp[i] 表示前i个字串分割成的部分

dp[i] = min( dp[j] +1) if j+1 到i的字符是回文串。

若是直接作，时间复杂度是O(n^3)的，只有java代码能过，能够预处理另一个状态数组f[i][j]， 在O(1)的时间判断i到j是否为回文，时间复杂度优化到O(n^2)

class Solution {
    private boolean check(String s){
        int left = 0, right = s.length()-1;
        while(left<right){
            if(s.charAt(left++)!=s.charAt(right--)) return false;
        }
        return true;
    } 
    public int minCut(String s) {
        int n = s.length();
        int[] dp = new int[n+1];
        dp[0] = 0;
        for(int i=1;i<=n;i++) dp[i] = Integer.MAX_VALUE;
        for(int i=1;i<=n;i++){
            for(int j=0;j<i;j++){
                if(check(s.substring(j,i))){
                    dp[i] = Math.min(dp[i],dp[j]+1);
                }
            }
        }
        return dp[n]-1;
    }
}