Leetcode 周赛 201

整理字符串

使用栈，若栈顶元素是当前元素的对应的大写/小写，则栈顶出栈，否则当前入栈

class Solution:
    def makeGood(self, s: str) -> str:
        stack=[]
        for ch in s:
            if stack and abs(ord(stack[-1])-ord(ch))==32:
                stack.pop()
            else:
                stack.append(ch)
        
        return ''.join(stack)

找出第 N 个二进制字符串中的第 K 位

递归求解，分情况讨论：

1.n==1 返回0
2.k==2**(n-1) 是当前的居中元素 返回 1
3.k位于后半截，即k>2**(n-1) 相当于求S(n-1)中的第2**n-k个元素，然后取反
4.k位于前半截，即k<2**(n-1) 相当于求S(n-1)中的第k个元素

返回是数值型，方便之后取反操作

class Solution:
    def findKthBit(self, n: int, k: int) -> str:
        def helper( n , k ):
            print(n,k)
            if n==1:
                return 0
            if k==2**(n-1):
                return 1
            if k>2**(n-1):
                return helper( n-1 , 2**n-k )^1
                '''
                01取反相当于与1异或
                '''
            return helper( n-1 , k )
        
        return str(helper(n,k))

和为目标值的最大数目不重叠非空子数组数目

不要求求长度只要求数量那就很方便的前缀和了

class Solution:
    def maxNonOverlapping(self, nums: List[int], target: int) -> int:
        prev=set([0])
        ans=0
        pre=0
        for ni in nums:
            pre+=ni
            '''
            贪心，之后重新开始
            '''
            if pre-target in prev:
                prev=set([0])
                ans+=1
                pre=0
            else:
                prev.add(pre)
        
        return ans

切棍子的最小成本

思路戳打气球类似，戳气球题目：https://leetcode-cn.com/problems/burst-balloons/
属于区间DP，状态转移方程为：

dp[j][k]表明从cut[j]位置到cut[k]位置全部切完所需的最小花销
dp[j][k]=min(dp[j][i]+dp[i][k]+arr[k]-arr[j])
dp[i][i+1]=0

class Solution:
    def minCost(self, n: int, cuts: List[int]) -> int:
        arr = [0] + sorted(cuts) + [n]
        @lru_cache(None)
        def helper(a, b):
            if a == b - 1:
                return 0
            return min((helper(a, i) + helper(i, b)) for i in range(a + 1, b)) + arr[b] - arr[a]
        return helper(0, len(arr) - 1)