算法作业第十周(leetcode)——132.palindrome-partitioning-ii

其实已经不是特别想做动态规划的题了，但是还是抽到了一道动态规划的题。下面给出题目描述：

                 https://leetcode.com/problems/palindrome-partitioning-ii/

这题的大意是给一个字符串，要经过最少多少次分割才能把字符串分成回文串组成的字符串。

其实这题动态规划的部分并不是特别难的部分。很容易就可以想到用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写法好了：