LeetCode - Palindrome Partitioning

題目鏈接：https://leetcode.com/problems/palindrome-partitioning/

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”]
]

I. 回溯法 + 一般迴文判斷

class Solution {
public:
    vector<vector<string> > partition(string s) {
        vector<vector<string> > ret;
        if (s.empty()) return ret;

        vector<string> subSet;
        dfs(ret, s, subSet, 0);
        return ret;
    }

    // subSet: the palindorme str set, from Origin[0, start - 1]; start: find palindorme from origin[start, end)
    void dfs(vector<vector<string> > &ret, const string &origin, vector<string> &subSet, int start)
    {
        if(start == origin.size()) //find one set of palindorme , return
        {
            ret.push_back(subSet);
            return;
        }
        string tmp;
        for(int i = start; i < origin.size(); i++)
        {
            tmp = origin.substr(start,  i - start + 1); //sub str
            if(isPalindorme(tmp))
            {
                subSet.push_back(tmp);
                // next start = i + 1
                dfs(ret, origin, subSet, i + 1);
                subSet.pop_back();
            }
        }
    }

    bool isPalindorme(const string &str)
    {
        int len = str.size();
        if(len == 0) //empty
            return false;
        else if(len == 1)
            return true;
        else {
            for(int i = 0; i < len / 2; i++){
                if(str[i] != str[len - 1 - i])
                    return false;
            }
            return true;
        }
    }
};

II. 回溯 + 動態規劃判定迴文

class Solution {
public:
    vector<vector<string> > partition(string s) {
        vector<vector<string> > ret;
        if (s.empty()) return ret;
        int n = s.size();
        vector<vector<bool> > dp(n, vector<bool>(n, false));
        //build dp, dp[i][j] = true means string range of [i, j], including j is a palindrome
        for(int len = 1; len <= n; len++) {
            for(int i = 0; i <= n - len; i++) {
                int j = i + len - 1;
                dp[i][j] = s[i] == s[j] && (i + 1 > j - 1 || dp[i + 1][j - 1]);
            }
        }

        vector<string> subSet;
        dfs(ret, s, subSet, 0, dp);
        return ret;
    }

    // subSet: the palindorme str set, from Origin[0, start - 1]; start: find palindorme from origin[start, end)
    void dfs(vector<vector<string> > &ret, const string &origin,
    vector<string> &subSet, int start, vector<vector<bool> > &dp)
    {
        if(start == origin.size()) //find one set of palindorme , return
        {
            ret.push_back(subSet);
            return;
        }
        for(int i = start; i < origin.size(); i++)
        {
            if(dp[start][i] == true) {
                subSet.push_back(origin.substr(start, i + 1 - start));
                dfs(ret, origin, subSet, i + 1, dp);
                subSet.pop_back();
            }
        }
    }

};