2024.9.12 Python 累加数，子串操作，分割回文串，长度最小的子数组，整数拆分

1.分割回文串

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文串返回 s 所有可能的分割方案。
示例 1：
输入：s = “aab”
输出：[[“a”,“a”,“b”],[“aa”,“b”]]
示例 2：
输入：s = “a”
输出：[[“a”]]

from typing import List
class Solution:
    def partition(self,s:str)->List[List[str]]:
        
        ans=[]
        def backtrack(i,path):  #1.
            if i ==len(s):  #2.
                ans.append(path[:])
                return
            for j in range(i,len(s)): #3.
                substr=s[i:j+1]
                if substr==substr[::-1]:
                    backtrack(j+1,path+[substr]) #4.
        backtrack(0,[])
        return ans

代码逻辑：
这个题我完全想明白了，在之前的8.26的文章中，我写了一种办法，但是那种办法我完全没有学会看懂，这次我理解了，首先把i理解为起点，把j理解为终点，backtrack(j+1)的目的是把当前字符串存起来以后，以j+1为起点进一步找回文串。大概逻辑这样以后我们深挖代码逻辑：
1.定义backtrack，backtrack的目标是，找以i为起始的字符串，判断是否为回文串，如果当前子串已经是回文串了，那么存起来，以下一个下标为基础继续找是否有回文串，如果有那么就继续重复，直到i为len(s)时停止
2.if的判断是给输出的条件
3.这个题的难点就在这里，这个for循环其实是遍历末尾的意思，从i到j的串如果是回文串，那么就继续下一层，如果不是回文串，那么就继续增大j
4.这样的写法就不需要pop了，直接加就ok了

2.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其总和大于等于 target 的长度最小的 子数组
[numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
示例 1：
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
示例 2：
输入：target = 4, nums = [1,4,4]
输出：1
示例 3：
输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        left=0
        right=0
        res=100001
        tmp_sum=nums[0]
        while right<len(nums):
            if tmp_sum<target:
                right+=1
                if right<len(nums):
                    tmp_sum+=nums[right]
        
            elif tmp_sum>=target:
                res=min(right+1-left,res)
                tmp_sum-=nums[left]
                left+=1
                if left>right:                    
                    right+=1
                    if right<len(nums):
                        tmp_sum+=nums[right]
                
            
        if res==100001:
            res=0
        return res

3.整数拆分

给定一个正整数 n ，将其拆分为 k 个 正整数 的和（ k >= 2 ），并使这些整数的乘积最大化。
返回 你可以获得的最大乘积 。
示例 1:
输入: n = 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1。
示例 2:
输入: n = 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。

class Solution:
    def integerBreak(self, n: int) -> int:
        if n <= 3:
            return n - 1
        
        dp = [0] * (n + 1)
        dp[2] = 1
        for i in range(3, n + 1):
            dp[i] = max(2 * (i - 2), 2 * dp[i - 2], 3 * (i - 3), 3 * dp[i - 3])
        
        return dp[n]

非常好的动态规划的例子，使我旋转

class Solution:
    def integerBreak(self, n: int) -> int:
        step=0
        if n==3:
            return 2
        if n==2:
            return 1
        while not (n==0 or n==2 or n==4):
            n-=3
            step+=1
        if n==0 :
            n=1
        return (3**step)*n

或者写成n//3和n%3来判断，无非就是几种可能，都考虑一下O(1)的计算方法就出来了。

4.累加数

累加数 是一个字符串，组成它的数字可以形成累加序列。
一个有效的 累加序列 必须 至少 包含 3 个数。除了最开始的两个数以外，序列中的每个后续数字必须是它之前两个数字之和。
给你一个只包含数字 ‘0’-‘9’ 的字符串，编写一个算法来判断给定输入是否是 累加数 。如果是，返回 true ；否则，返回 false 。
说明：累加序列里的数，除数字 0 之外，不会 以 0 开头，所以不会出现 1, 2, 03 或者 1, 02, 3 的情况。
示例 1：
输入：“112358”
输出：true
解释：累加序列为: 1, 1, 2, 3, 5, 8 。1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8
示例 2：
输入：“199100199”
输出：true
解释：累加序列为: 1, 99, 100, 199。1 + 99 = 100, 99 + 100 = 199

class Solution:
    def isAdditiveNumber(self, num: str) -> bool:
        def addStrings(num1, num2):
            i, j, carry, result = len(num1) - 1, len(num2) - 1, 0, []
            while i >= 0 or j >= 0 or carry:
                digit1 = int(num1[i]) if i >= 0 else 0
                digit2 = int(num2[j]) if j >= 0 else 0
                total = digit1 + digit2 + carry
                carry = total // 10
                result.append(str(total % 10))
                i, j = i - 1, j - 1
            return ''.join(result[::-1])

        def isValidSequence(start1, start2):
            prevStart, currStart, nextStart = 0, start1, start2
            while nextStart < len(num):# 3.
                if (num[prevStart] == '0' and start1 > prevStart + 1) or (num[currStart] == '0' and start2 > currStart + 1):
                    return False #4.
                expectedSum = addStrings(num[prevStart:currStart], num[currStart:nextStart])#5.
                if num[nextStart:nextStart+len(expectedSum)] != expectedSum:   #6.
                    return False

                prevStart, currStart, nextStart = currStart, nextStart, nextStart + len(expectedSum)
            return True

        for firstEnd in range(1, len(num) - 1):
            for secondEnd in range(firstEnd + 1, len(num)):
                if isValidSequence(firstEnd, secondEnd):
                    return True
        return False

代码逻辑：
1.addString函数，用来计算两个字符串的加法，比如[1,2,3]和[4,5,6,7]相加，那么就应该是7和3加，然后carry记录升位，如果i已经=-1了，那么就输出0，分别计算每一位，存入列表里，然后之后再反向输出’'.join。写这个代码的目的是为了处理大数，万一这个字符串究极大，那么单纯的int加减就会非常的难。尤其是C语言的时候。
2.isValid函数是判断分组后的字符串是否是按照要求的，其实还是双指针，第一个指针最开始是不动的，所以进函数的时候是0，while跳出的条件是，第三个指针超出len的时候，就跳了
3.while函数的目的是为了在当前条件下，向下走，而不是确定cur边界，就是说，在下面的for循环中，我们用来确定前两个数具体是谁，然后我们根据前两个数来计算第三个值的期望，如果他是我们要找的值，那么就往下走，检查下一组，
4.首先加限定条件，如果指针一指到了0，同时指针二和他隔了一个，也就是说currStart>prev+1，那么就可以判死刑了，current指针也如此，如果遇到，0，同时下一个还隔了一个，那告辞。
5.expectedSum = addStrings(num[prevStart:currStart], num[currStart:nextStart])这个算下来就是我们的期望，我们希望第三个数是谁
6.num[nextStart:nextStart+len(expectedSum)]这个很巧，如果不一致直接告辞，继续下一次分割，如果一致，那么就像链表一样，全部向下移动一格，while安然结束，return True
7.两个for循环循所有的起始。
8.if not num.startswith(expectedSum, nextStart): return False这个代码可以替换6.的代码。