給你一個字串 s，請你將 s 分割成一些子串，使每個子串都是迴文。

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

示例 1：

輸入：s = "aab"
輸出：1
解釋：只需一次分割就可將s 分割成 ["aa","b"] 這樣兩個迴文子串。
示例 2：

輸入：s = "a"
輸出：0
示例 3：

輸入：s = "ab"
輸出：1

提示：

1 <= s.length <= 2000
s 僅由小寫英文字母組成

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/palindrome-partitioning-ii

參考：

• 官方

python

# 0132.分割回文串II

class Solution:
    def minCut(self, s: str) -> int:
        """
        動態規劃
        :param s:
        :return:
        """
        length = len(s)
        dp = [[True] * length for _ in range(length)]
        for i in range(length-1, -1, -1):
            for j in range(i+1, length):
                dp[i][j] = (s[i]==s[j]) and dp[i+1][j-1]
        f = [float("INF")] * length
        for i in range(length):
            if dp[0][i]:
                f[i] = 0
            else:
                for j in range(i):
                    if dp[j+1][i]:
                        f[i] = min(f[i], f[j]+1)
        return f[length-1]


    def minCut_(self, s: str) -> int:
        """
        參考題131, 回溯法超時間
        :param s:
        :return:
        """
        res = []
        path = []

        def isPalindrome(s):
            n = len(s)
            i, j = 0, n - 1
            while i < j:
                if s[i] != s[j]: return False
                i += 1
                j -= 1
            return True

        def track(s, startIndex):
            # 起始位置已經大於s的大小，說明已經找到一組分割方案
            if startIndex >= len(s):
                res.append(path[:])
                return
            for i in range(startIndex, len(s)):
                # 獲取[startIndex:i+1]的子串
                p = s[startIndex:i + 1]
                if isPalindrome(p):
                    path.append(p)
                else:
                    continue
                track(s, i + 1)
                path.pop()  # 回溯

        track(s, 0)

        MIN = 10000
        for item in res:
            length = len(item)
            MIN = min(MIN, length-1)
        return MIN
 

golang

待完善