[Leetcode] Palindrome Partitioning II

Given a string s, partition s such that every substring of the partition is a palindrome.

Return the minimum cuts needed for a palindrome partitioning of s.

For example, given s = "aab",
Return 1 since the palindrome partitioning ["aa","b"] could be produced using 1 cut.

动态规划，dp[i]表示从s_0到s_i的最小cut，为了避免重复比较，定义标记矩阵flag[i][j]，用来存储s_i到s_j是否为回文。

class Solution {
public:
    int minCut(string s) {
        vector<int> dp(s.length(), 0);
        vector<vector<bool> > flag(s.length(), vector<bool>(s.length(), false));
        flag[0][0] = true;
        for (int i = 1; i < s.length(); ++i) {
            flag[i][i] = true;
            dp[i] = dp[i-1] + 1;
            for (int len = 1; len < i + 1; ++len) {
                if (s[i-len] == s[i] && (len < 2 || flag[i-len+1][i-1])) {
                    dp[i] = (i - len == 0) ? 0 : min(dp[i], dp[i-len-1] + 1);
                    flag[i-len][i] = true;
                }
            }
        }
        return dp[s.length() - 1];
    }
};

换个字母代码更好理解一些。

class Solution {
public:
    int minCut(string s) {
        vector<int> dp(s.length(), 0);
        vector<vector<bool> > flag(s.length(), vector<bool>(s.length(), false));
        flag[0][0] = true;
        for (int j = 1; j < s.length(); ++j) {
            flag[j][j] = true;
            dp[j] = dp[j-1] + 1;
            for (int i = 0; i < j; ++i) {
                if (s[i] == s[j] && (i == j - 1 || flag[i+1][j-1])) {
                    dp[j] = (i == 0) ? 0 : min(dp[j], dp[i-1] + 1);
                    flag[i][j] = true;
                }
            }
        }
        return dp[s.length()-1];
    }
};

DFS版本超时了。

class Solution {
public:
    bool isPail(string &s) {
        int low = 0, high = s.length() - 1;
        while (low < high) {
            if (s[low] != s[high]) {
                return false;
            }
            ++low;
            --high;
        }
        return true;
    }
    
    void findNext(vector<vector<string> > &res, string &s, vector<string> part, int idx) {
        if (idx == s.length()) {
            res.push_back(part);
            return;
        }
        string substr;
        for (int len = s.length() - idx; len > 0; --len) {
            substr = s.substr(idx, len);
            if (isPail(substr)) {
                part.push_back(substr);
                findNext(res, s, part, idx + len);
                part.pop_back();
            }
        }
    }
    
    int minCut(string s) {
        vector<vector<string> > res;
        vector<string> part;
        findNext(res, s, part, 0);
        int min = INT_MAX;
        for (int i = 0; i < res.size(); ++i) {
            min = (min > res[i].size()) ? res[i].size() : min;
        }
        return min - 1;
    }
};