1276. 不浪费原料的汉堡制作方案

1276. 不浪费原料的汉堡制作方案

class Solution:
    def numOfBurgers(self, tomatoSlices: int, cheeseSlices: int) -> List[int]:
        if tomatoSlices > cheeseSlices * 4:
            return []
        jumbo_min = 0
        jumbo_max = cheeseSlices
        while True:
            jumbo_mid = jumbo_min + (jumbo_max - jumbo_min) // 2
            this = (jumbo_mid * 4 + (cheeseSlices - jumbo_mid) * 2)
            if this < tomatoSlices:
                jumbo_min = jumbo_mid
            elif this > tomatoSlices:
                jumbo_max = jumbo_mid
            else:
                return [jumbo_mid, cheeseSlices - jumbo_mid]
            if jumbo_max - jumbo_min == 1:
                break
        return []

2160. 拆分数位后四位数字的最小和

2160. 拆分数位后四位数字的最小和

class Solution:
    def minimumSum(self, num: int) -> int:
        num = [int(n) for n in str(num) if n != '0']
        num.sort()
        if len(num) <= 2:
            return sum(num)
        elif len(num) == 3:
            return num[0] * 10 + num[1] + num[2]
        else:
            return num[0] * 10 + num[3] + num[1] * 10 + num[2]

2058. 找出临界点之间的最小和最大距离

2058. 找出临界点之间的最小和最大距离

class Solution:
    def nodesBetweenCriticalPoints(self, head: Optional[ListNode]) -> List[int]:
        res = [float('inf'), float('-inf')]
        pre_node = head
        node = head.next
        front_pos = 0
        last_pos = 1
        now_pos = 1
        mark = False
        while node.next:
            if (node.val > pre_node.val and node.val > node.next.val) or (node.val < pre_node.val and node.val < node.next.val):
                if mark:
                    res[0] = min(res[0], now_pos - last_pos)
                    res[1] = max(res[1], now_pos - front_pos)
                else:
                    front_pos = now_pos
                last_pos = now_pos
                mark = True
            pre_node = node
            node = node.next
            now_pos += 1
        if res == [float('inf'), float('-inf')]:
            return [-1, -1]
        if res == [0, 0]:
            return [-1, -1]
        return res

2481. 分割圆的最少切割次数

2481. 分割圆的最少切割次数

class Solution:
    def numberOfCuts(self, n: int) -> int:
        if n == 1:
            return 0
        return n // 2 if n % 2 == 0 else n

1080. 根到叶路径上的不足节点

1080. 根到叶路径上的不足节点

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


class Solution:
    def sufficientSubset(self, root: Optional[TreeNode], limit: int) -> Optional[TreeNode]:
        res = self.dfs(root, limit, 0)
        return root if res is not True else None

    def dfs(self, node: Optional[TreeNode], limit: int, val):
        left_delete = True
        right_delete = True
        val += node.val
        if not node.left and not node.right:
            return val < limit
        if node.left:
            left_delete = self.dfs(node.left, limit, val)
        if node.right:
            right_delete = self.dfs(node.right, limit, val)

        if left_delete:
            node.left = None
        if right_delete:
            node.right = None
        return all((right_delete, left_delete))

2609. 最长平衡子字符串

2609. 最长平衡子字符串

class Solution:
    def findTheLongestBalancedSubstring(self, s: str) -> int:
        zero = 0
        one = 0
        res = 0
        for c in s:
            if c == '0' and one != 0:
                res = max(min(one, zero), res)
                one = 0
                zero = 0
            if c == '0':
                zero += 1
            elif c == '1':
                one += 1
        res = max(min(one, zero), res)
        return res * 2