132. 分割回文串 II

Q:

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回符合要求的最少分割次数。

示例:

输入: “aab”
输出: 1
解释: 进行一次分割就可将 s 分割成 [“aa”,“b”] 这样两个回文子串。

A:

1.我最开始想到了要两次DP，先算一个是否是回文数的dp数组，再算所求的DP。
但第二个DP数组我用的二维数组，然后就变成了O(N^3)时间。因为对于其中每个元素都要从左边界遍历到右边界进行分割，没有想到可以利用第一个DP中的数据。
代码是对的，自己机器跑了，但AC不了，第26个用例超时：

超时的代码！：

 class Solution:
     def minCut(self, s: str) -> int:
         #先算一个dp数组记录是否是回文数
         #dp[i][j]记录s[i,j]闭区间是否是回文数
         l=len(s)
         if not s:
             return 0
         dp=[[0 for i in range(l)] for j in range(l)]
         for i in range(l):
             dp[i][i]=1  #一个元素的一定是回文数，递推起始条件
         for i in range(l-1):
             if s[i]==s[i+1]:
                 dp[i][i+1]=1    #两个相邻元素的若值相同，也为回文数
         for step in range(2,l):
             i=0
             while i+step<l:
                 j=i+step    #j为右边界,考察s[i,j]是否是回文数
                 #矩阵的右上半部，满足i<=j才有意义
                 dp[i][j]=int(dp[i+1][j-1] and s[i]==s[j])
                 #当前字符串为回文数的条件：两边界截掉是回文数
                 i+=1
         #回文数dp数组建立好，考虑对于s[i,j]字符串的最少分割次数f(i,j)，
         #若当前字符串为回文数即dp[i][j]==1则分割次数f(i,j)为0，不用割，
         #否则可能的切割位置为i+1到j-1，假设切割位置为k（i<k<j），
         #还需要知道f(i,k),f(k+1,j),故还需要一个求最少分割次数的dp数组
         dp2=[[float('inf') for i in range(l)] for j in range(l)]
         for i in range(l):
             dp2[i][i]=0     #单个字符串不用割，其他元素初始化为无穷大
         for step in range(1,l):  #对[i,i+step]闭区间考察，i取0时，0+step应该小于l
             i=0
             while i+step<l:
                 if dp[i][i+step]==1:    #若s[i,i+step]已是回文
                     dp2[i][i+step]=0
                 else:
                     #若s[i,i+step]不是回文，则一定要切，下面开始切
                     cur_min=float('inf')
                     for cut in range(i,i+step):
                         #找割数最小的割法
                         cur_min=min(cur_min,dp2[i][cut]+dp2[cut+1][i+step]+1)
                     dp2[i][i+step]=cur_min
                 i+=1
         # print(dp)
         # print(dp2)
         return dp2[0][l-1]

2.正确代码：
第一个dp数组一样，必须是二维的。第二个dp数组一维的，dp2[i]表示从i开始到末尾的字符串的最小分割数，对于每个dp[i]，在i+1到n-1找分割点k就完事了，i到k为回文串通过第一个DP数组查询，O(1) ，剩下的k到n-1是之前算好的，所以第二个DP数组要从右往左算，因为右边界不动。总体O(N^2)复杂度。

c++:

 class Solution {
 public:
     #define inf INT_MAX
     int minCut(string s) {
         int n=s.size();
         vector<vector<bool>> is_huiwen(n,vector<bool>(n,false));
         for(int i=0;i<n;++i){is_huiwen[i][i]=true;}
         for(int i=0;i<n-1;++i){is_huiwen[i][i+1]=(s[i]==s[i+1]?true:false);}
         //下往上，左往右算dp
         for(int i=n-3;i>=0;--i){
             for(int j=i+2;j<n;++j){
                 is_huiwen[i][j]=(s[i]==s[j] and is_huiwen[i+1][j-1])?true:false;
             }
         }
         vector<int> dp(n,inf);//dp[i]表示s截止到i最小分割次数（inf表示没法分割）
         for(int i=0;i<n;++i){
             if(is_huiwen[0][i]){
                 dp[i]=0;
                 continue;
             }
             for(int cut=1;cut<=i;++cut){
                 if(is_huiwen[cut][i] and dp[cut-1]!=inf){
                     dp[i]=min(dp[i],dp[cut-1]+1);
                 }
             }
         }
         return dp[n-1];
     }
 };

python:

 class Solution:
     def minCut(self, s: str) -> int:
         l=len(s)    #先算一个dp数组记录是否是回文，dp[i][j]记录s[i,j]闭区间是否是回文数
         if not l:
             return 0
         dp=[[0 for i in range(l)] for j in range(l)]
         for i in range(l-1,-1,-1):  #从下往上，从右往左算
             for j in range(l-1,i-1,-1):
                 if s[i]==s[j]:
                     dp[i][j]=1 if j-i<2 else dp[i+1][j-1]
         dp2=[float('inf') for i in range(l)]  #dp2[i]表示从i开始到末尾字符串的最小分割数
         for i in range(l-1,-1,-1):
             if dp[i][l-1]:  #当前字符串是回文数
                 dp2[i]=0
             else:
                 _min=float('inf')
                 for cut in range(i,l-1):    #不同割点位置
                     if dp[i][cut]==1:
                         _min=min(dp2[cut+1]+1,_min)
                 dp2[i]=_min
         print(dp2)
         return dp2[0]