leetcode【132】Palindrome Partitioning II【c++版，动态规划，时间87%，空间100%】

问题描述：

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.

Example:

Input: "aab"
Output: 1
Explanation: The palindrome partitioning ["aa","b"] could be produced using 1 cut.

源码：

动态规划大法，我最初的做法是先先为（pail[j, i]表示第 j 到 i 元素的子串是回文）回文串做一次。第二次再动态规划dp[i]表示前i个字母最少需要切割的次数。

dp[i] = min(dp[i], dp[j-1]+1); 前提是j到i必须是回文。

后来发现两个回文是能重叠的。就写到了一个循环低下。

最后的效率还是不高。时间36%，空间100%。

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

在网上找了一下，有一些大佬的方案还是比较叼的，他也使用动态规划，dp[i] 表示由s串中前 i 个字母组成的子串的最小分割数，这样 dp[n] 极为最终所求。接下来就要找状态转移方程了。这道题的更新方式比较特别，跟之前的都不一样，之前遍历 i 的时候，都是更新的 dp[i]，这道题更新的却是 dp[i+len+1] 和 dp[i+len+2]，其中 len 是以i为中心，总长度为 2*len + 1 的回文串，比如 bob，此时 i=1，len=1，或者是i为中心之一，总长度为 2*len + 2 的回文串，比如 noon，此时 i=1，len=1。中间两个for循环就是分别更新以 i 为中心且长度为 2*len + 1 的奇数回文串，和以 i 为中心之一且长度为 2*len + 2 的偶数回文串的。i-len 正好是奇数或者偶数回文串的起始位置，由于我们定义的 dp[i] 是区间 [0, i-1] 的最小分割数，所以 dp[i-len] 就是区间 [0, i-len-1] 范围内的最小分割数，那么加上奇数回文串长度 2*len + 1，此时整个区间为 [0, i+len]，即需要更新 dp[i+len+1]。如果是加上偶数回文串的长度 2*len + 2，那么整个区间为 [0, i+len+1]，即需要更新 dp[i+len+2]。最后时间95%，空间100%。

class Solution {
public:
    int minCut(string s) {
        if (s.empty()) return 0;
        int n = s.size();
        vector<int> dp(n + 1, INT_MAX);
        dp[0] = -1;
        for (int i = 1; i <= n; ++i) {
            for (int len = 0; i-1 - len >= 0 && i-1 + len < n && s[i-1 - len] == s[i-1 + len]; ++len) {
                dp[i + len] = min(dp[i + len], 1 + dp[i-1 - len]);
            }
            for (int len = 0; i-1 - len >= 0 && i + len < n && s[i-1 - len] == s[i + len]; ++len) {
                dp[i + len + 1] = min(dp[i + len + 1], 1 + dp[i-1 - len]);
            }
        }
        return dp[n];
    }
};