Constraints

• 0 <= len(logs) <= 200000
• 0 <= dasherId <= 10^9
• 0 <= startTime < endTime <= 10^9
• endTime is exclusive

Examples

Solution

def solution(logs):
    from collections import defaultdict

    by_dasher = defaultdict(list)
    for dasher_id, start, end in logs:
        if start < end:
            by_dasher[dasher_id].append((start, end))

    merged = []
    for intervals in by_dasher.values():
        intervals.sort()
        cur_start, cur_end = intervals[0]
        for start, end in intervals[1:]:
            if start <= cur_end:
                if end > cur_end:
                    cur_end = end
            else:
                merged.append((cur_start, cur_end))
                cur_start, cur_end = start, end
        merged.append((cur_start, cur_end))

    events = []
    for start, end in merged:
        events.append((start, 1))
        events.append((end, -1))

    events.sort(key=lambda x: (x[0], x[1]))

    busy = 0
    best = 0
    for _, delta in events:
        busy += delta
        if busy > best:
            best = busy
    return best

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

Hints

1. First combine each dasher's intervals so overlapping or touching intervals become one busy block.
2. After merging per dasher, the problem becomes a standard interval overlap sweep.

Constraints

• 0 <= len(logs) <= 200000
• 0 <= dasherId <= 10^9
• 0 <= startTime < endTime <= 10^9
• You should target O(n log n) time

Examples

Solution

def solution(logs):
    from collections import defaultdict

    events = []
    for dasher_id, start, end in logs:
        if start < end:
            events.append((start, 1, dasher_id))
            events.append((end, -1, dasher_id))

    events.sort(key=lambda x: (x[0], x[1], x[2]))

    active_orders = defaultdict(int)
    busy = 0
    best = 0

    for _, delta, dasher_id in events:
        if delta == 1:
            if active_orders[dasher_id] == 0:
                busy += 1
            active_orders[dasher_id] += 1
        else:
            active_orders[dasher_id] -= 1
            if active_orders[dasher_id] == 0:
                busy -= 1
                del active_orders[dasher_id]

        if busy > best:
            best = busy

    return best

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

Hints

1. Sort events by (time, delta, dasherId) if you encode end as -1 and start as +1.
2. Multiple starts for the same dasher at the same time should not raise the busy count more than once; track active orders per dasher.

Constraints

• 0 <= len(events) <= 200000
• 0 <= dasherId <= 10^9
• 0 <= time <= 10^9
• delta is either -1 or 1

Examples

Solution

def solution(events):
    return sorted(events, key=lambda x: (x[1], x[2], x[0]))

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

Hints

1. The sweep-line must move through time globally, so time has to be the first sort key.
2. When two events share the same time, an end event should come before a start event because endTime is exclusive.

Constraints

• 0 <= len(logs) <= 200000
• 0 <= dasherId <= 10^9
• 0 <= startTime < endTime <= 10^9
• Orders for the same dasher do not overlap

Examples

Solution

def solution(logs):
    events = []
    for _, start, end in logs:
        if start < end:
            events.append((start, 1))
            events.append((end, -1))

    events.sort(key=lambda x: (x[0], x[1]))

    current = 0
    best = 0
    for _, delta in events:
        current += delta
        if current > best:
            best = current
    return best

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

Hints

1. You no longer need per-dasher active counts, because each order can be counted directly.
2. Use the standard interval sweep: add +1 at starts and -1 at ends, with ends processed before starts at the same time.