其实已经不是特别想做动态规划的题了,但是还是抽到了一道动态规划的题。下面给出题目描述:
这题的大意是给一个字符串,要经过最少多少次分割才能把字符串分成回文串组成的字符串。
其实这题动态规划的部分并不是特别难的部分。很容易就可以想到用cut[i]来表示前i个字符所能分成的回文串的最小个数。然后用一个数组p[i][j]来表示[i,j)之间的子串是不是回文串,然后就可实现cut[i]到cut[j]之间的状态转移。
我个人觉得难点主要在怎么在o(n^2)时间内实现回文串的判断。如果直接遍历,那肯定是o(n^3)。一开始想到栈,但是回文串可能有奇数个字符,不能一一对应。后来看了一下网上发现,回文串去掉两边相同的字符还是回文串。利用这个性质,我们可以实现一个简单的递归:
int p[2005][2005];
int cut[2005];
class Solution {
public:
int isParlindrome(string& s, int i,int j)
{
if(i>=j-1)
return 1;
if(p[i][j]!=-1)
return p[i][j];
if(s[i]!=s[j-1])
return 0;
p[i][j] = isParlindrome(s, i+1, j-1);
return p[i][j];
}
int minCut(string s) {
int i,j;
memset(p, -1, sizeof(p));
memset(cut, -1, sizeof(cut));
for(i=0;i<s.size();i++)
{
if(isParlindrome(s,0,i+1))
cut[i] = 1;
for(j=0;j<i;j++)
{
if(isParlindrome(s,j+1,i+1))
{
if(cut[i]!=-1)
cut[i] = min(cut[i],cut[j]+1);
else
cut[i] = cut[j] + 1;
}
}
}
return cut[s.size()-1]-1;
}
};
这里懒得写vector,直接开了一波数组然后memset。。。。。所以很慢。。。(个人感觉是这个原因,没实验过)
其实这个还可以用循环实现,不过我感觉要搞清数组依赖的关系比较复杂,相对难想。我个人实现了一个循环版本:
int p[2005][2005];
int cut[2005];
class Solution {
public:
int minCut(string s) {
int i,j;
memset(p, -1, sizeof(p));
memset(cut, -1, sizeof(cut));
for(i=0;i<s.size();i++)
{
if(s[0]==s[i]&&(p[1][i]==1||i<=1))
{
p[0][i+1] = 1;
cut[i] = 1;
}
for(j=0;j<i;j++)
{
if(s[j+1]==s[i]&&(p[j+2][i]==1||j>=i-2))
{
p[j+1][i+1] = 1;
if(cut[i]!=-1)
cut[i] = min(cut[i],cut[j]+1);
else
cut[i] = cut[j] + 1;
}
}
}
return cut[s.size()-1]-1;
}
};
快了一点,如果想要再快就改成vector写法好了: