每日一道Leetcode-131.分割回文串 [动态规划]

class Solution:
    def partition(self, s: str) -> List[List[str]]:
        # 利用中心扩散来存储left-right的回文字符的情况
        def fromCenterJudge(s,left,right,dp):
            while left>=0 and right<len(s) and s[left]==s[right]:
                dp[left][right]=True
                left -= 1
                right += 1
        def dfs(res,path,s,start,dp):
            # 已经遍历完的情况
            if start==len(s):
                res.append(path.copy())
                return
            for i in range(start,len(s)):
                if not dp[start][i]:
                    continue
                path.append(s[start:i+1])
                dfs(res,path,s,i+1,dp)
                path.pop()

        res = []
        path = []
        dp = [[False]*len(s) for _ in range(len(s))]
        # 先把回文字符串的情况都判断一遍，存起来结果
        for i in range(len(s)):
            fromCenterJudge(s,i,i,dp)
            fromCenterJudge(s,i,i+1,dp)
        # 再调用方法去一个个判断
        start = 0
        dfs(res,path,s,start,dp)
        return res

class Solution:
    def minCut(self, s: str) -> int:
        # 先动态规划预处理
        def fromCenterJudge(s,left,right,dp):
            while left>=0 and right<len(s) and s[left]==s[right]:
                dp[left][right]=True
                left -= 1
                right += 1
        
        dp = [[False]*len(s) for _ in range(len(s))]

        for i in range(len(s)):
            fromCenterJudge(s,i,i,dp)
            fromCenterJudge(s,i,i+1,dp)
        
        # res代表考虑下标i的字符为结尾的最小分割次数
        res = [0]*len(s)
        # 开始判断
        for j in range(1,len(s)):
            if dp[0][j]:
                # 从头到当前位置就可以构成，所以不用分割
                res[j]=0
            else:
                # 独立分割,当前各成一派
                res[j] = res[j-1]+1
                # 不独立分割，与前面有联系的(划到一起的)情况
                # [i-1]之前的+[i,j]算一次
                for i in range(1,j):
                    if dp[i][j]:
                        res[j] = min(res[j],res[i-1]+1)
        return res[-1]