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 源码
细节:
- 动态规划的四要素:状态、方程、初始化、答案。(四要素在之前的题目数字三角形1中有详细介绍)
- 状态:用
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;
//}
数字三角形:https://blog.csdn.net/SeeDoubleU/article/details/124678103 ↩︎