leetcode-Palindrome Partitioning II

Palindrome Partitioning II

 Total Accepted: 11791 Total Submissions: 66110

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.

Have you been asked this question in an interview?

  Yes

这道题是Palindrome Partitioning的变形，要求求出最小的分割使得全部分割后的子串都是回文串。

能够在Palindrome Partitioning的基础上改动。在找到可行解时。更新最优解。

class Solution {
public:
    int minCut(string s) {
        ans = INT_MAX;
        findMinCut(s, 0, 0);
        return ans;
    }
private:
    int ans;
    
    void findMinCut(const string &s, int k, int currCut) {
        string substr;
        for (int i=k; i<s.size(); ++i) {
            if (isPalindrome(s, k, i)) {
                if (i+1 == s.size()) {
                    if (currCut+1 < ans) {
                        ans = currCut+1;
                    }
                } else {
                    findMinCut(s, i+1, currCut+1);
                }
            }
        }
    }
    
    bool isPalindrome(const string &s, int b, int e) {
        int i=b, j=e;
        while (i<j) {
            if (s[i] != s[j])
                return false;
            ++i;
            --j;
        }
        return true;
    }
};

假设添加记忆化搜索+剪枝，还是会TLE。超时的case是一大串"aaaa...aa"的情况。

class Solution {
public:
    int minCut(string s) {
        minCutNum = INT_MAX;
        vector<string> paths;
        find(s, 0, paths);
        return minCutNum;
    }
private:
    int minCutNum;
    map<int, int> minCutsMap;
    void find(const string& s, int ind, vector<string>& paths)
    {
        for (int i = ind; i < s.size(); ++i) {
            if (isPalindrome(s, ind, i)) {
                if (paths.size() > minCutNum)
                    continue;
                if (minCutsMap.find(i+1) != minCutsMap.end()) {
                    if (paths.size() + minCutsMap.size() - 1 < minCutNum) {
                        minCutNum = paths.size() + minCutsMap.size() - 1;
                    }
                    continue;
                }
                paths.push_back(s.substr(ind, i - ind + 1));
                if (i + 1 == s.size()) {
                    if (minCutNum > paths.size() - 1) {
                        minCutNum = paths.size() - 1;
                    }
                    paths.pop_back();
                    continue;
                }
                int num = paths.size();
                minCutsMap[i + 1] = INT_MAX;
                find(s, i + 1, paths);
                if (minCutsMap[i + 1] > paths.size() - num) {
                    minCutsMap[i + 1] = paths.size() - num;
                }
                if (minCutNum == 0)
                    return;
                paths.pop_back();
            }
        }
    }
    bool isPalindrome(const string& str, int begin, int end)
    {
        while (begin < end) {
            if (str[begin] != str[end])
                return false;
            ++begin; --end;
        }
        return true;
    }
};

最后网上參考了别人的DP，自己写了下，最终看到Accepted。

初始化isPalindrome的方法也是用了DP的方法，跟计算矩阵连乘最小操作数类似。

如果字符串为str。长度为n，计算最小分割数的状态转移方程为：dp[i] = min{dp[j]+1,dp[i]}(j=i+1...n-1), 当中dp[i]为str[i]...str[n-1]的最小分割数。在做DP题时，要考虑清楚怎么存状态，以及状态是怎样转移的。DP的长处就是可以依据曾经的选择来做出当下最优的选择，像贪心算法就不能，仅仅有曾经局部最优的状态。

class Solution {
public:
    int minCut(string s) {
        int len = s.size();
        bool **isPalindrome = new bool*[len];
        for (int i = 0; i < len; ++i) {
            isPalindrome[i] = new bool[len];
        }
        initIsPalindrome(isPalindrome, s);
        
        int *dp = new int[len]; // dp[i] stores minimum cuts for s[i]...s[len-1]
        for (int i = len - 1; i >= 0; --i) {
            if (isPalindrome[i][len - 1]) {
                dp[i] = 0;
                continue;
            }
            dp[i] = INT_MAX;
            for (int j = i + 1; j < len; ++j) {
                if (isPalindrome[i][j - 1]) {
                    if (dp[j] + 1 < dp[i]) {
                        dp[i] = dp[j] + 1;
                    }
                }
            }
        }
        int ret = dp[0];
        for (int i = 0; i < len; ++i)
            delete []isPalindrome[i];
        delete []isPalindrome;
        delete dp;
        return ret;
    }
private:
    void initIsPalindrome(bool ** isPalindrome, const string& s) {
        int len = s.length();
        for (int L = 1; L <= len; ++L) { // L is the length of substring, from 1 to len
            for (int i = 0; i < len - L + 1; ++i) { // i is the starting index
                int j = i + L - 1; // j is the ending index
                if (L == 1) {
                    isPalindrome[i][j] = true;
                } else if (L == 2) {
                    isPalindrome[i][j] = s[i] == s[j];
                } else {
                    isPalindrome[i][j] = (s[i] == s[j]) && isPalindrome[i + 1][j - 1];
                }
            }
        }
    }
};