Constraints

• 0 <= number of days in `hours` <= 7
• 0 <= total number of reservations across all days <= 10^4
• Each day in `hours` has exactly one opening interval with open_time < close_time
• Each reservation has start_time < end_time before clamping
• `duration` is either `None` or an integer between 1 and 1440

Examples

Solution

def solution(hours, reservations, duration=None):
    def to_minutes(value):
        if isinstance(value, int):
            return value
        h, m = value.split(':')
        return int(h) * 60 + int(m)

    def to_hhmm(minutes):
        return f"{minutes // 60:02d}:{minutes % 60:02d}"

    min_duration = 0 if duration is None else duration
    available = {}

    for day, window in hours.items():
        open_time = to_minutes(window[0])
        close_time = to_minutes(window[1])

        if open_time >= close_time:
            available[day] = []
            continue

        blocked = []
        for start, end in reservations.get(day, []):
            s = to_minutes(start)
            e = to_minutes(end)

            if e <= open_time or s >= close_time:
                continue

            s = max(s, open_time)
            e = min(e, close_time)
            if s < e:
                blocked.append([s, e])

        blocked.sort()

        merged = []
        for s, e in blocked:
            if not merged or s > merged[-1][1]:
                merged.append([s, e])
            else:
                merged[-1][1] = max(merged[-1][1], e)

        free = []
        current = open_time
        for s, e in merged:
            if current < s and s - current >= min_duration:
                free.append([to_hhmm(current), to_hhmm(s)])
            current = max(current, e)

        if current < close_time and close_time - current >= min_duration:
            free.append([to_hhmm(current), to_hhmm(close_time)])

        available[day] = free

    return available

Time complexity: O(R log R), where R is the total number of reservations across all days. Space complexity: O(R).

Hints

1. For each day, sort the reservations by start time and merge any intervals that overlap or touch.
2. After merging, walk from opening time to closing time and collect the gaps between blocked intervals.