You are given an integer `n`, the number of meeting rooms, numbered `0` through `n - 1`, and a list `meetings` where `meetings[i] = [start_i, end_i]` describes a meeting that wants to run over the half-open interval `[start_i, end_i)`. All start times are pairwise distinct, but `meetings` is **not** guaranteed to be given in sorted order. Process the meetings in increasing order of start time. A room is free at time `t` if no meeting is occupying it, or if the meeting occupying it ends at a time less than or equal to `t`. For each meeting in turn: - If at least one room is free at the meeting's start time, hold the meeting in the free room with the **smallest number**. It occupies that room over `[start_i, end_i)`. - If no room is free, delay the meeting until the earliest time any room becomes free. A delayed meeting keeps its original duration `end_i - start_i`, so if the chosen room frees at time `f` the meeting occupies `[f, f + (end_i - start_i))`. If several rooms become free at that same earliest time `f`, use the one with the **smallest number**. A room's meeting count is the number of meetings it hosts, whether they started on time or were delayed. Return the number of the room that hosts the most meetings. If several rooms are tied for the most meetings, return the **smallest** such room number. **Output semantics.** Return a single integer: a room number in `[0, n - 1]`. Every choice above resolves ties by smallest room number, so exactly one answer is correct for any valid input. **Note on magnitudes.** Delaying meetings pushes end times past the largest original end time. Under the constraints below every time value stays below `201000000000000` (about `2.01 * 10^14`), which exceeds the range of a 32-bit signed integer. Java implementations must accumulate these times in `long` and C++ implementations in `long long`; the room numbers and the returned value still fit in `int`. ### Example 1 ```text Input: n = 2, meetings = [[0, 10], [1, 5], [2, 7], [3, 4]] Output: 0 ``` - `[0, 10)` starts first and takes room 0, which is then busy until 10. - `[1, 5)` finds room 0 busy and takes room 1, busy until 5. - `[2, 7)` finds both rooms busy. Room 1 frees earliest, at time 5. The meeting keeps its duration of 5 and runs `[5, 10)` in room 1. - `[3, 4)` finds both rooms busy, and both free at time 10. The smaller number wins, so it runs `[10, 11)` in room 0. Room 0 hosts 2 meetings and room 1 hosts 2 meetings. The counts are tied, so the smaller room number is returned: `0`. ### Example 2 ```text Input: n = 3, meetings = [[1, 20], [2, 10], [3, 5], [4, 9], [6, 8]] Output: 1 ``` - `[1, 20)` takes room 0, `[2, 10)` takes room 1, and `[3, 5)` takes room 2. - `[4, 9)` finds every room busy. Room 2 frees earliest, at time 5, so the meeting keeps its duration of 5 and runs `[5, 10)` in room 2. - `[6, 8)` finds every room busy. Rooms 1 and 2 both free at time 10, so the smaller number wins and the meeting runs `[10, 12)` in room 1. Room 0 hosts 1 meeting, room 1 hosts 2, and room 2 hosts 2. Rooms 1 and 2 are tied for the most, so the smaller room number is returned: `1`.