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;
    }
}