Request `i` wants server `i % k`, and when that one is busy it walks forward — `i+1`, `i+2`, past `k-1` and around to `0` — until something is free. That walk is the entire problem, and writing it out literally is the trap: a `for` loop over `k` slots per request costs `1e10` steps at the upper bound, and it looks harmless while you type it because it exits on the first try almost every time. Read the walk as a query instead and it stops being a loop. What it asks for is the smallest free id that is at least `i % k`, falling back to the smallest free id overall. That is `lower_bound` on an ordered set of free ids plus one `begin()` fallback for the wrap. The other half is noticing when servers come back: keep the in-flight ones in a min-heap by finish time and drain everything that finished by `arrival[i]` before you ask the set anything. ### Worked example `k = 3`, `arrival = [1,2,3,4,5]`, `load = [5,2,3,3,3]`. - `i=0`, `t=1`: idle `{0,1,2}`, `lower_bound(0)` → server 0, busy until 6. Counts `[1,0,0]`. - `i=1`, `t=2`: nothing has finished, idle `{1,2}`, `lower_bound(1)` → server 1, busy until 4. Counts `[1,1,0]`. - `i=2`, `t=3`: idle `{2}` → server 2, busy until 6. Counts `[1,1,1]`. - `i=3`, `t=4`: heap top is `(4,1)` and `4 <= 4`, so server 1 returns. Idle `{1}`, target is `3 % 3 = 0`, `lower_bound(0)` → server 1. Counts `[1,2,1]`. - `i=4`, `t=5`: finish times are 6, 6 and 7, nobody is back, the idle set is empty and the request is dropped. Counts end at `[1,2,1]`, the max is 2 and only server 1 holds it, so the answer is `[1]`. ### Complexity - Time O((n + k) log k) — one ordered-set lookup per request, and a server enters and leaves the heap at most once per request it handles. - Space O(k) — the idle set, the heap and the counter array are each bounded by the server count. ### Code (C++) ```cpp class Solution { public: vector busiestServers(int k, vector& arrival, vector& load) { set idle; for (int i = 0; i < k; ++i) idle.insert(i); // (finish time, server id), smallest finish time on top priority_queue, vector>, greater>> busy; vector cnt(k, 0); int n = arrival.size(); for (int i = 0; i < n; ++i) { long long t = arrival[i]; // everything that finished by t is available again while (!busy.empty() && busy.top().first <= t) { idle.insert(busy.top().second); busy.pop(); } if (idle.empty()) continue; // dropped auto it = idle.lower_bound(i % k); if (it == idle.end()) it = idle.begin(); // wrap around int s = *it; idle.erase(it); ++cnt[s]; busy.push({t + load[i], s}); } int best = *max_element(cnt.begin(), cnt.end()); vector res; for (int i = 0; i < k; ++i) { if (cnt[i] == best) res.push_back(i); } return res; } }; ``` ### One note `busy.top().first <= t` is the line that decides the submission, and example 1 is built to catch it. Server 1 finishes at exactly second 4, request 3 arrives at exactly second 4, and the expected output counts that request. Write `<` there and you return `[0,1,2]` instead of `[1]` — one character, and the reasoning that produces it ("it's still finishing at 4") sounds fine in your head. The quieter trap is the heap key. `arrival[i]` and `load[i]` both reach `1e9`, so a finish time reaches `2e9` and overflows a signed 32-bit `int`. The small samples never show it; on a large test the overflowed finish time wraps negative, a busy server reads as free, and the counts drift with nothing in the return type hinting that time was ever the problem. Two things worth carrying off. When a statement says "next available, wrapping around", that phrase is `lower_bound` with a `begin()` fallback, not a scan — the circular part is one line, not a loop. And when correctness hangs on a boundary, go find the sample input that separates `<` from `<=` rather than picking the one that reads better.