LeetCode 132 分割回文串II HERODING的LeetCode之路

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文。

返回符合要求的 最少分割次数 。

示例 1：

输入：s = “aab”
输出：1
解释：只需一次分割就可将 s 分割成 [“aa”,“b”] 这样两个回文子串。

示例 2：

输入：s = “a”
输出：0

示例 3：

输入：s = “ab”
输出：1

提示：

1 <= s.length <= 2000
s 仅由小写英文字母组成

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-partitioning-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路：
一开始本来想通过修改昨天的代码，即通过回溯DFS+DP的方式解决问题，发现超时了。。。细究原因确实没有必要回溯，因为在dp过后就可以通过一次遍历的方式找出最少的切割方法了，这里先给出回溯DFS+DP的代码，代码如下：

class Solution {
private:
    // 判断i到j是否为回文串
    vector<vector<bool>> judge;
    //字符串长度
    int len;
    //最少次数
    int min_time = 999999;
public:
    void dfs(const string& s, int i, int& times) {
        if (i == len) {
            min_time = min(min_time, times);
            return;
        }
        for (int j = i; j < len; ++j) {
            if (judge[i][j]) {
                times ++;
                dfs(s, j + 1, times);
                // 回溯
                times --;
            }
        }
    }

    int minCut(string s) {
        len = s.size();
        judge.assign(len, vector<bool>(len, true));
        for (int i = len - 1; i >= 0; --i) {
            for (int j = i + 1; j < len; ++j) {
                // 动态规划思想，i到j是否为回文串取决于i与j是否相等或者s[i]、s[j]相等，[i + 1]到[j - 1]范围内满足回文
                judge[i][j] = (s[i] == s[j]) && judge[i + 1][j - 1];
            }
        }
        int times = 0;
        dfs(s, 0, times);
        return min_time - 1;

    }
};

下面对只用dp的解释，第一次dp是找出所有的回文串，judge[i][j]，i到j是否为回文串取决于i与j是否相等或者s[i]、s[j]相等，[i + 1]到[j - 1]范围内满足回文，第二个状态转移方程是 times[i] = min(times[i], times[j] + 1)，此时的条件是 judge[j + 1][i] == True，即 j+1 到 i 是回文串，更新的是最小次数，注解已经很详尽了，代码如下：

class Solution {
public:
    int minCut(string s) {
        int len = s.size();
        vector<vector<bool>> judge(len, vector<bool>(len, true));
        for (int i = len - 1; i >= 0; --i) {
            for (int j = i + 1; j < len; ++j) {
                // 动态规划思想，i到j是否为回文串取决于i与j是否相等或者s[i]、s[j]相等，[i + 1]到[j - 1]范围内满足回文
                judge[i][j] = (s[i] == s[j]) && judge[i + 1][j - 1];
            }
        }
        vector<int> times(len, INT_MAX);
        for(int i = 0; i < len; i ++) {
            if(judge[0][i]) {
                times[i] = 0;
            } else {
                for(int j = 0; j < i; j ++) {
                    // 如果j + 1 到 i 是回文串
                    if(judge[j + 1][i]) {
                        times[i] = min(times[i], times[j] + 1);
                    }
                }
            }
        }
        return times[len - 1];
    }
};



/*作者：heroding
链接：https://leetcode-cn.com/problems/palindrome-partitioning-ii/solution/liang-ci-dpcxiang-jie-by-heroding-48zi/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。*/