LeetCode 每日一题 2026/2/2-2026/2/8

记录了初步解题思路 以及本地实现代码；并不一定为最优 也希望大家能一起探讨 一起进步

---

目录

• • • [2/2 3013. 将数组分成最小总代价的子数组 II](#2/2 3013. 将数组分成最小总代价的子数组 II)
    • [2/3 3637. 三段式数组 I](#2/3 3637. 三段式数组 I)
    • [2/4 3640. 三段式数组 II](#2/4 3640. 三段式数组 II)
    • [2/5 3379. 转换数组](#2/5 3379. 转换数组)
    • [2/6 3634. 使数组平衡的最少移除数目](#2/6 3634. 使数组平衡的最少移除数目)
    • [2/7 1653. 使字符串平衡的最少删除次数](#2/7 1653. 使字符串平衡的最少删除次数)
    • [2/8 110. 平衡二叉树](#2/8 110. 平衡二叉树)

2/2 3013. 将数组分成最小总代价的子数组 II

第一个数确定nums[0]

ans记录除第一个数外的代价

sL记录当前dist长度的滑动窗口的数值从小到大

def minimumCost(nums, k, dist):
    """
    :type nums: List[int]
    :type k: int
    :type dist: int
    :rtype: int
    """
    from sortedcontainers import SortedList
    k-=1
    sL=SortedList(nums[1:dist+2])
    ans=s=sum(sL[:k])
    
    for i in range(dist+2,len(nums)):
        if nums[i]<sL[k-1]:
            s+=nums[i]-sL[k-1]
        sL.add(nums[i])
        sL.remove(nums[i-dist-1])
        if nums[i-dist-1]<sL[k-1]:
            s+=sL[k-1]-nums[i-dist-1]
        ans=min(ans,s)
    return nums[0]+ans

---

2/3 3637. 三段式数组 I

从头依次判断

第二个数必须大于第一个数

必定不能存在相邻两数相等

cur=1当前为严格递增

tag=True 当前已经有过递减

def isTrionic(nums):
    """
    :type nums: List[int]
    :rtype: bool
    """
    if nums[0]>nums[1]:
        return False
    cur=1
    tag=False
    for i in range(1,len(nums)):
        if nums[i-1]==nums[i]:
            return False
        if cur==1:
            if nums[i-1]>nums[i]:
                if tag:
                    return False
                else:
                    tag=True
                    cur=0
        else:
            if nums[i-1]<nums[i]:
                cur=1
    if tag and cur==1:
        return True
    return False

---

2/4 3640. 三段式数组 II

找到所有 增减增的子数组

i,p,q为增减增的第一个位置

减数组所有数值都需要

第三个增数组必要q,q+1 从q+2开始 尽可能取 让和最大

第一个增数组必要p,p-1 从p-2往回 尽可能取 让和最大

def maxSumTrionic(nums):
    """
    :type nums: List[int]
    :rtype: int
    """
    n=len(nums)
    ans=float("-inf")
    i=0
    while i<n:
        j=i+1
        res=0
        
        while j<n and nums[j-1]<nums[j]:
            j+=1
        p=j-1
        
        if p==i:
            i+=1
            continue
        
        res+=nums[p]+nums[p-1]
        while j<n and nums[j-1]>nums[j]:
            res+=nums[j]
            j+=1
        q=j-1
        
        if q==p or q==n-1 or (j<n and nums[j]<=nums[q]):
            i=q
            continue
        res+=nums[q+1]
        maxs=0
        curs=0
        k=q+2
        while k<n and nums[k]>nums[k-1]:
            curs+=nums[k]
            maxs=max(maxs,curs)
            k+=1
        res+=maxs
        
        maxs=0
        curs=0
        for k in range(p-2,i-1,-1):
            curs+=nums[k]
            maxs=max(maxs,curs)
        res+=maxs
        
        ans=max(ans,res)
        i=q
    return ans

---

2/5 3379. 转换数组

依次执行

def constructTransformedArray(nums):
    """
    :type nums: List[int]
    :rtype: List[int]
    """
    n=len(nums)
    ans=[0]*n
    
    for i in range(n):
        if nums[i]==0:
            ans[i]=nums[i]
        else:
            target = (i+nums[i])%n
            ans[i]=nums[target]
    return ans

---

2/6 3634. 使数组平衡的最少移除数目

排序

双指针 left为最小值 right为可达到最大值 n-(right-left)即为需要删去的数目

def minRemoval(nums, k):
    """
    :type nums: List[int]
    :type k: int
    :rtype: int
    """
    nums.sort()
    n=len(nums)
    ans=n
    r=0
    for l in range(n):
        while r<n and nums[r]<=nums[l]*k:
            r+=1
        ans=min(ans,n-(r-l))
    return ans
    

---

2/7 1653. 使字符串平衡的最少删除次数

平衡需要满足以下条件之一

所有字符是a

所有字符是b

有a,b 所有a在b左边

如果当前位置i是a,b分割点 达到平衡需要删除x左侧的b和右侧的a

def minimumDeletions(s):
    """
    :type s: str
    :rtype: int
    """
    lb=0
    ra=s.count('a')
    ans=ra
    for c in s:
        if c=='a':
            ra-=1
        else:
            lb+=1
        ans=min(ans,lb+ra)
    return ans

---

2/8 110. 平衡二叉树

class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

def isBalanced( root):
    """
    :type root: TreeNode
    :rtype: bool
    """
    if root==None:
        return True
    
    def depth(node):
        l =[]
        if node==None:
            return 0
        l.append((node,1))
        ret =1
        while len(l)>0:
            n,level = l.pop(0)
            if n.left!=None:
                l.append((n.left,level+1))
                ret = max(ret,level+1)
            if n.right!=None:
                l.append((n.right,level+1))
                ret = max(ret,level+1)
        return ret
            
    
    if root.left!=None and root.right!=None:
        ret = isBalanced(root.left) and isBalanced(root.right)
        if ret:
            ret = abs(depth(root.left)-depth(root.right))<2
        return ret
    if root.left==None and root.right==None:
            return True
    
    if root.left == None:
        node = root.right
        if node.left!=None or node.right!=None:
            return False
    
    if root.right == None:
        node = root.left
        if node.left!=None or node.right!=None:
            return False
    return True

---