97 切分回文串II（Palindrome Partitioning II）-优快云博客

本文链接：https://blog.youkuaiyun.com/SeeDoubleU/article/details/136893031

文章目录

1 题目

题目：切分回文串II（Palindrome Partitioning II）
描述：给定字符串 s，需要将它分割成一些子串，使得每个子串都是回文串。最少需要分割几次？

lintcode题号——108，难度——medium

样例1：

输入：s = "a"
输出：0
解释："a" 本身就是回文串, 无需分割

样例2：

输入：s = "aab"
输出：1
解释：将 "aab" 分割一次, 得到 "aa" 和 "b", 它们都是回文串.

2 解决方案

2.1 思路

使用动态规划的方式解，将状态定义为表示将前i个数分割成回文串的最少次数，则如果j+1到i为回文，前i个数分割的最少次数=min(前j个数分割的最少次数 + 1，当前前i个数的最优解)，理清动态规划的四要素即可解出。
在判断如果j+1到i为回文的时候，如果直接实时计算，会导致子串的重复计算，可以再用一次动态规划来预计算出一个回文检查表。

区间型动态规划：与序列型动态规划相同，由于将状态定义成前i个字符的状态，所以前0个对象的状态~前i个对象的状态，一共有i+1个状态，所以容器的长度需要增加一位。但是，不同的是下标的依赖需要理清，如果小下标依赖大下标，则要从尾部向头部遍历。

2.2 时间复杂度

本题动态规划的多重循环是对同一维的下标进行的，相当于在一个耗时n的循环内嵌套了同为耗时n的循环，时间复杂度为O(n^2)。

2.3 空间复杂度

使用了容量为n的数组，空间复杂度为O(n)。

3 源码

细节：

动态规划的四要素：状态、方程、初始化、答案。（四要素在之前的题目数字三角形¹中有详细介绍）
状态：用dp[i]表示将前i个数分割成回文串的最少次数。
方程：dp[i] = min(dp[j] + 1, dp[i])，如果j+1到i为回文，前i个数分割的最少次数=min(前j个数分割的最少次数，当前前i个数的最优解)。
初始化：每个串按单字符切分，子串都是回文。
答案：到达右下角的路径数，即dp[max]。

dp需要开辟原数组大小再+1的空间，为了加上dp[0]来表示空串，方便后续计算的通用性。
在方式的判断条件中，需要判断dp中j+1到i为回文，因为dp的下标与回文检查表的下标偏移一位，所以需要检查的是原数组中j到i-1的位置。

还有另外一些细节需要注意的：

为了与方程前i个数分割的最少次数=min(前j个数分割的最少次数，当前前i个数的最优解)能够通用匹配，在初始化的时候会将dp[0]赋为-1。
方程的判断条件如果j+1到i为回文，对回文进行判断时，如果直接实时计算，会导致子串的重复计算，可以再用一次动态规划来预计算出一个回文检查表。
对这个回文检查表的动态规划中，初始化需要初始化两层，因为dp[i][j]需要通过其左下角的dp[i+1][j-1]来计算，需要副对角线上的两层初始化，才能覆盖之后的所有节点的推导。也可以使用外层len，内层i的方式，加上2==len的判断条件来规避两层初始化的问题，因为2==len且s[i]==s[j]即表示形如“aa”的回文。
回文检查表中的动态规划是区间型的，在多重循环时，外层循环使用len，内层循环使用起点start。

C++版本：

/**
* @param s: A string
* @return: An integer
*/
int minCut(string &s) {
    // write your code here
    if (s.empty())
    {
        return 0;
    }

    // 判断区间内是否回文串，预计算出一个回文检查表，防止实时计算的重复
    // 状态：dp[i][j]表示从位置i到位置j的子串是否为回文串
    //vector<vector<int>> isPalindrome(s.size(), vector<int>(s.size(), 0));

    /*
    // 初始化：所有单字符都是回文串
    for (int i = 0; i < s.size(); i++)
    {
        isPalindrome[i][i] = 1;
    }
    //初始化：所有双字符相同的都是回文串
    //多初始化这一组是因为dp[i][j]需要通过其左下角的dp[i+1][j-1]来计算
    //如果不初始化两层，则有一半的数据无法计算
    for (int i = 0; i + 1 < s.size(); i++)
    {
        if (s.at(i) == s.at(i + 1))
        {
            isPalindrome[i][i + 1] = 1;
        }
    }

    // 长度从3开始，前面初始化已经算完了1和2的长度
    for (int len = 2; len < s.size(); len++)
        for (int start = 0; start + len < s.size(); start++)
    {
        {
            int i = start;
            int j = start + len;
            // 方程：如果位置i+1到j-1为回文，且位置i与位置j字符相同，则位置i到位置j是回文
            if (s[i] == s[j])
            {
                isPalindrome[i][j] = isPalindrome[i + 1][j - 1];
            }
        }
    }
    */

    //预先动态规划出从i到j是否回文的结果表
    vector<vector<bool>> isPalindrome(s.size(), vector<bool>(s.size(), false));
    for (int i = 0; i < s.size(); i++) {
        isPalindrome[i][i] = true;
    }
    for (int len = 2; len <= s.size(); len++) {
        for (int i = 0; i <= s.size() - len; i++) {
            int j = i + len - 1;
            if (s[i] == s[j] && (len == 2 || isPalindrome[i + 1][j - 1])) { //通过外层len，内层i，加上"len==2"的判断，可以只进行单层初始化
                isPalindrome[i][j] = true;
            }
        }
    }

    // 状态：dp[i]表示将前i个数分割成回文串的最少次数
    vector<int> dp(s.size() + 1, INT_MAX);

    // 初始化：每个串按单字符切分，子串都是回文，为了统一计算会将空串赋为-1
    for (int i = 0; i < dp.size(); i++)
    {
        dp[i] = i - 1;
    }

    for (int i = 1; i < dp.size(); i++)
    {
        for (int j = 0; j < i; j++)
        {
            // 方程：如果j+1到i为回文，前i个数分割的最少次数=min(前j个数分割的最少次数，当前前i个数的最优解)
            // if (checkPalindrome(s, j, i - 1) == true) // 如果直接只用函数实时check回文串的有效性，会导致重复计算，最好再使用一次动态规划
            if (isPalindrome[j][i - 1] == true)
            {
                dp[i] = min(dp[j] + 1, dp[i]);
            }
        }
    }

    return dp[dp.size() - 1]; // 答案：所有字符分割成回文串的最少次数
}

// 判断回文串
//bool checkPalindrome(string & s, int left, int right)
//{
//    while (left < right)
//    {
//        if (s.at(left) != s.at(right))
//        {
//            return false;
//        }
//
//        left++;
//        right--;
//    }
//
//    return true;
//}