【palindrome partitioning II】cpp

题目：

Given a string s, partition s such that every substring of the partition is a palindrome.

Return the minimum cuts needed for a palindrome partitioning of s.

For example, given s = "aab",
Return 1 since the palindrome partitioning ["aa","b"] could be produced using 1 cut.

代码：

class Solution {
public:
        int minCut(string s)
        {
            const int len = s.size();
            vector<vector<bool> > p(len, vector<bool>(len,false));
            Solution::allPalindrome(p, s);
            vector<int> dp(len, INT_MAX);
            dp[] = ;
            for ( int i = ; i < len; ++i )
            {
                for ( int j = i; j >= ; --j )
                {
                    if ( j== )
                    {
                        if ( p[j-][i] )
                        {
                            dp[i] = ;
                            break;
                        }
                    }
                    if ( p[j][i] )
                    {
                        dp[i] = std::min(dp[i], dp[j-]+);
                    }
                }
            }
            return dp[len-];
        }
        // palindromes[i][j] denotes if s[i:j] is palindrome
        static void allPalindrome(vector<vector<bool> >& palindromes, string& s)
        {
            for ( int i = palindromes.size()-; i >= ; --i )
            {
                for ( int j = i; j <= palindromes.size()-; ++j )
                {
                    if ( (i+>j- && s[i]==s[j]) || (i+<=j- && s[i]==s[j] && palindromes[i+][j-]) )
                    {
                        palindromes[i][j] = true;
                    }
                }
            }
        }
};

tips：

通过此题掌握了动态规划的一些套路。

动规的核心在于求解两个重要的变量

p[i][j] : 代表s[i]到s[j]是否构成一个回文

dp[i] : 标记s[0]到s[i]的最小回文分割

接下来阐述上述两个变量的生成过程：

1. p[i][j]

正确地求出p[i][j]就是成功的一半，第一次没有AC主要就是p[i][j]求错了。在这里详细记录一下正确的求解过程

第一步，要明确p[i][j]的含义，即s[i]到s[j]是否为回文。

第二步，把求解p[i][j]转化为状态转移方程，即p[i][j] = f(p[k][v]) (k<=i, v<=j, 且k==i,v==j不同时成立)。

这个看起来是一个二维的dp方程，条件什么的比较麻烦，但实际上方程比较简单。

p[i][j] = s[i]==s[j] && p[i+1][j-1]

相当于两个条件

a) 首尾相等

b) 中间子字符串是回文

当然，还要处理一些极端情况：

极端情况1：i==j

极端情况2：i==j+1

把极端的case处理好，就可以开始dp过程了

另，因为是回文（正反都一样）所以求解p的时候，只用求解上三角阵就可以了。

2. dp[i]

之前理解dp有一个误区：认为dp[i]由dp[i-1]一步推倒过来。这是非常不正确的。

正确的理念应该是：dp[i]应该由dp[0]~dp[i-1]导出。（即当前结受到已计算出的中间结果影响，只不过有时候用不到回溯那么靠前的中间结果，只用回溯上一步的结果dp[i-1]就可以了）

然而，这道题正好不能只回溯一步，而是要回溯所有之前步骤。

既然要回溯，就要有规则，规则要保证不重不漏。这里我们关注的点是s[i]：即，我们求dp[i]则s[i]是一定要包含在其中某个回文字串中的，具体如下：

s[i]自己是一个回文子串

s[i-1:i]构成回文子串

s[i-2:i]构成回文子串

...

s[0:i]构成回文串

上述的i+1种情况如果都讨论到了，则dp[i]也就求出来了。

具体阐述如下：

s[0] ... s[i-2] s[i-1] s[i]：如果p[i-1][i]==true （即s[i-1]~s[i]是回文），则如果切割点在s[i-2]与s[i-1]之间，则dp[i] = min ( dp[i] , dp[i-2]+1)

....

s[0] ... s[j-1] s[j] ... s[i]：如果p[j][i]==true，则如果切割点在dp[i] = min ( dp[i], dp[j-1]+1)

s[0] ... s[i] ：如果p[0][i]==true，则不用切割也可以，故最小切割数是0。

按照上述的思路，再处理一下corner case，代码也就出来了。

=====================================

这份代码在处理corner cases上面做的不太好，有很多可以避免的冗余。但是先保留着吧，毕竟是原始的思考思路。第二遍刷的时候，再精细化一些corner case。

======================================

第二次过这道题，看了第一次做的思路，代码重新写了一遍，比第一次过的时候要简洁一些。

class Solution {
public:
        int minCut(string s)
        {
            const int n = s.size();
            vector<vector<bool> > p(n, vector<bool>(n,false));
            Solution::isPalindrome(p, s);
            int dp[n];
            fill_n(&dp[], n, );
            for ( int i=; i<n; ++i )
            {
                if ( p[][i] )
                {
                    dp[i]=;
                    continue;
                }
                int cuts = INT_MAX;
                for ( int j=i; j>; --j)
                {
                    if ( p[j][i] ) cuts = min(cuts, dp[j-]+);
                    if ( cuts== ) break;
                }
                dp[i] = cuts;
            }
            return dp[n-];
        }
        static void isPalindrome(vector<vector<bool> >& p, string s)
        {
            for ( int i=; i<s.size(); ++i )
            {
                for ( int j=; j<=i; ++j )
                {
                    if ( i-j< )
                    {
                        p[j][i] = s[i]==s[j];
                    }
                    else
                    {
                        p[j][i] = s[i]==s[j] && p[j+][i-];
                    }
                }
            }
        }

};