leetcode132. Palindrome Partitioning II

leetcode132. Palindrome Partitioning II

题意：

给定一个字符串s，分区使分区的每个子字符串都是回文。

返回对于s的回文分割所需的最小削减。

例如，给定s =“aab”，

返回1，因为可以使用1切割生成回文分割[“aa”，“b”]。

思路：

一开始我用dfs + 贪心来做，找到最长的回文，然后拆掉继续dfs，然后最后一个测试样例过不了，不是复杂度的问题，是算法本身有问题。

看了别人的思路，是用dp来做的，设DP[i][j]表示第i个字符到第j个字符是否构成回文，若是，则DP[i][j]=1;若否，则DP[i][j]=0;如此，根据回文的约束条件（对称性），DP[i][j]构成回文需满足：

1、输入字符串s[i]==s[j],对称性；

2、条件1满足并不能保证i到j构成回文，还须：（j-i）<=1或者DP[i+1][j-1]=1；即，i、j相邻或者i=j，也就是相邻字符相等构成回文或者字符自身构成回文，如果i、j不相邻或者相等，i到j构成回文的前提就是DP[i+1][j-1]=true

所以状态转移方程：DP[i][j]=(s[i]s[j]&&(j-i<=1||DP[i+1][j-1]1))。由于i必须小于j，i>=0&&i<s.length().如此，DP[i][j]构成一个下三角矩阵，空间、时间复杂度均为O(n2),如下所示：对于长度为4的字符串s=“baab”，其中红色部分为i>j，为无意义部分；绿色部分i==j，即字符串自身必然构成回文，DP[i][j]=1;白色部分，为长度大于1的子串，需要状态转移方程进行判断。

ac代码：

C++

class Solution {
public:
    int minCut(string s) {
        int len = s.length();
        vector<vector<bool> >map(len,vector<bool>(len));
        for(int i = len - 1; i >= 0; i--)
        {
            for(int j = i; j < len; j++)
            {
                if(i == j)
                {
                    map[i][j] = true;
                }
                else if(i + 1 == j)
                {
                    if(s[i] == s[j])
                    {
                        map[i][j] = true;
                    }
                }
                else
                {
                    if(s[i] == s[j] && map[i + 1][j - 1])
                    {
                        map[i][j] = true;
                    }
                }
            }
        }

        vector<int> res(len + 1,0);
        for(int i = len - 1; i >= 0; i--)
        {
            res[i] = res[i + 1] + 1;
            for(int j = i + 1; j < len; j++)
            {
                if(map[i][j] == true && res[j + 1] + 1 < res[i])
                    res[i] = res[j + 1] + 1;
            }
        }
        return res[0] - 1;
    }
};

python

参考博文

• link