Constraints

• 0 <= len(root) <= 2000
• Each non-None node value is an integer in the range [-10^4, 10^4]
• The input list represents a valid binary tree in level-order form

Examples

Solution

def solution(root):
    from collections import deque

    if not root:
        return []

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

    values = iter(root)
    first = next(values)
    if first is None:
        return []

    tree_root = TreeNode(first)
    build_queue = deque([tree_root])

    while build_queue:
        node = build_queue.popleft()
        try:
            left_val = next(values)
        except StopIteration:
            break
        if left_val is not None:
            node.left = TreeNode(left_val)
            build_queue.append(node.left)

        try:
            right_val = next(values)
        except StopIteration:
            break
        if right_val is not None:
            node.right = TreeNode(right_val)
            build_queue.append(node.right)

    result = []
    bfs_queue = deque([tree_root])
    left_to_right = True

    while bfs_queue:
        level = []
        for _ in range(len(bfs_queue)):
            node = bfs_queue.popleft()
            level.append(node.val)
            if node.left:
                bfs_queue.append(node.left)
            if node.right:
                bfs_queue.append(node.right)

        if not left_to_right:
            level.reverse()
        result.append(level)
        left_to_right = not left_to_right

    return result

Time complexity: O(n). Space complexity: O(n).

Hints

1. A breadth-first search naturally processes the tree one level at a time.
2. You can collect each level left-to-right, then reverse every other level before appending it to the answer.

Constraints

• 1 <= num_courses <= 10^5
• 0 <= len(prerequisites) <= 2 * 10^5
• Each prerequisite pair has length 2
• 0 <= course, prerequisite < num_courses

Examples

Solution

def solution(num_courses, prerequisites):
    from collections import deque

    graph = [[] for _ in range(num_courses)]
    indegree = [0] * num_courses

    for course, prereq in prerequisites:
        graph[prereq].append(course)
        indegree[course] += 1

    queue = deque([i for i in range(num_courses) if indegree[i] == 0])
    finished = 0

    while queue:
        current = queue.popleft()
        finished += 1
        for nxt in graph[current]:
            indegree[nxt] -= 1
            if indegree[nxt] == 0:
                queue.append(nxt)

    return finished == num_courses

Time complexity: O(num_courses + len(prerequisites)). Space complexity: O(num_courses + len(prerequisites)).

Hints

1. Think of courses as nodes in a directed graph and prerequisites as directed edges.
2. If you repeatedly take courses with indegree 0 and cannot process all nodes, a cycle exists.

Constraints

• 0 <= len(s) <= 2 * 10^5
• 0 <= k <= len(s)
• s may contain any standard characters

Examples

Solution

def solution(s, k):
    if k == 0 or not s:
        return 0

    counts = {}
    left = 0
    best = 0

    for right, ch in enumerate(s):
        counts[ch] = counts.get(ch, 0) + 1

        while len(counts) > k:
            left_ch = s[left]
            counts[left_ch] -= 1
            if counts[left_ch] == 0:
                del counts[left_ch]
            left += 1

        best = max(best, right - left + 1)

    return best

Time complexity: O(len(s)). Space complexity: O(min(len(s), k)).

Hints

1. A sliding window can maintain a valid substring while expanding to the right.
2. Keep character counts in the current window, and shrink from the left whenever the number of distinct characters exceeds k.