Palindrome Partitioning II|leetcode题解

此问题适合使用动态规划求解，因为此问题具有最优子结构性质和重叠子问题。

开始地时候，我是如此定义问题的结构的：

设dp[i][j]代表s[i..j]的最小切割数，则如果s[i..j]是回文串，则dp[i][j]=0。否则，dp[i][j]=min{dp[i][k],dp[k+1][j]}，其中i<=k<j;

则可使用动态规划，填dp的上三角表，dp[0][n-1]就是问题的解。

bool isPalindrome(string s, int l, int r){
        if(r<=l)return true;
        while(l<r){
            if(s[l++]!=s[r--])return false;
        }
    
        return true;
    }

    int minCut(string s) {  
        int n=s.size();
        if(0==n||1==n)return 0;
        vector<vector<int> >dp(n,vector<int>(n,n));
        for(int i=0;i<n;i++)dp[i][i]=0;
        for(int l=1;l<n;l++){
            for(int i=0;i<n-l;i++){
                int j=i+l;
                if(isPalindrome(s,i,j))dp[i][j]=0;
                else{
                    for(int k=i;k<j;k++){
                        int t=dp[i][k]+dp[k+1][j]+1;
                        if(dp[i][j]>t)dp[i][j]=t;
                    }
                }
            }
        }
    
        return dp[0][n-1];
    }

提交的结果是超时的，因为这里面的isPlindrome子程序的使用，使得整个程序上升了一个复杂度。

那么，是否能够省去这个子程序呢？

由于回文串存在下面的性质:s[i..j]是回文串，当且仅当，(s[i]==s[j])并且(j-i<=1或者s[i+1][j-1])是回文串，

表达式是if((s[i]==s[j])&&(j-i<=1||s[i+1][i-1]是回文字符串)则s[i][j]是回文字符串。

基于此性质，我们需要用表格存储s[i][j]是否为回文字符串。

那么，在我们知道s[i][j]是回文字符串时，那么以j结尾的字符串s[0..j]的最小切割数cut[j]，就是min(cut[i-1]+1,cut[j])了（i==0是例外，此时cut[j]=0）。

并且，cut[j]是最有子结构和无后效性的。那么程序就自然而然了，如下：

 int minCut(string s) {
        int n=s.size();
        if(0==n||1==s.size())return 0;
        vector<vector<bool> >dp(n,vector<bool>(n,false));
        vector<int>cut(n,n);
        for(int j=0;j<n;j++){
            cut[j]=j;
            for(int i=0;i<=j;i++){
                if((s[i]==s[j])&&(j-i<=1||dp[i+1][j-1])){
                    dp[i][j]=true;
                    if(0==i)cut[j]=0;
                    else{
                        cut[j]=min(cut[i-1]+1,cut[j]);
                    }
                }
            }
        }
    
        return cut[n-1];
    }

动态规划方面的经验，还是有点少，需要积累，特别是状态和状态转移方程的选择，很需要技巧性，当程序Time Limit Exceeded时，要仔细想想解决方案。

此时，说不定才能够接触到问题的本质。