时间复杂度：change O(logn)，find O(1)
空间复杂度：O(n)

class NumberContainers {
public:
  NumberContainers() {}
  
  void change(int index, int number) {
    if (m_.count(index)) {
      auto it = idx_.find(m_[index]);
      it->second.erase(index);
      if (it->second.empty())
        idx_.erase(it);
    }
    m_[index] = number;
    idx_[number].insert(index);
  }
  
  int find(int number) {
    auto it = idx_.find(number);
    if (it == end(idx_)) return -1;
    return *begin(it->second);
  }
private:
  unordered_map<int, int> m_; // index -> num
  unordered_map<int, set<int>> idx_; // num -> {index}
};

用了三个Hashtable…

1. 菜名 -> 菜系
2. 菜系 -> Treemap
3. 菜名 -> 所在Treemap中的迭代器

每个菜系用一个TreeSet来保存从高到低的菜色排名，查询的时候只要拿出第一个就好了。

修改的时候，拿出迭代器，删除原来的评分，再把新的评分加入（别忘了更新迭代器）

时间复杂度：构造O(nlogn)，修改O(logn)，查询O(1)

空间复杂度：O(n)

class FoodRatings {
public:
  FoodRatings(vector<string>& foods, vector<string>& cuisines, vector<int>& ratings) {
    const int n = foods.size();
    for (int i = 0; i < n; ++i) {
      n_[foods[i]] = cuisines[i];
      m_[foods[i]] = c_[cuisines[i]].emplace(-ratings[i], foods[i]).first;
    }
  }
  
  void changeRating(string food, int newRating) {
    const string& cuisine = n_[food];
    c_[cuisine].erase(m_[food]);
    m_[food] = c_[cuisine].emplace(-newRating, food).first;
  }
  
  string highestRated(string cuisine) {
    return begin(c_[cuisine])->second;
  }
private:
  unordered_map<string, set<pair<int, string>>> c_; // cuisine -> {{-rating, name}}
  unordered_map<string, string> n_; // food -> cuisine  
  unordered_map<string, set<pair<int, string>>::iterator> m_; // food -> set iterator
};

/**
 * Your FoodRatings object will be instantiated and called as such:
 * FoodRatings* obj = new FoodRatings(foods, cuisines, ratings);
 * obj->changeRating(food,newRating);
 * string param_2 = obj->highestRated(cuisine);
 */

Each movie is given as a 2D integer array entries where entries[i] = [shopi, moviei, pricei] indicates that there is a copy of movie moviei at shop shopi with a rental price of pricei. Each shop carries at most one copy of a movie moviei.

The system should support the following functions:

• Search: Finds the cheapest 5 shops that have an unrented copy of a given movie. The shops should be sorted by price in ascending order, and in case of a tie, the one with the smaller shopi should appear first. If there are less than 5 matching shops, then all of them should be returned. If no shop has an unrented copy, then an empty list should be returned.
• Rent: Rents an unrented copy of a given movie from a given shop.
• Drop: Drops off a previously rented copy of a given movie at a given shop.
• Report: Returns the cheapest 5 rented movies (possibly of the same movie ID) as a 2D list res where res[j] = [shopj, moviej] describes that the jth cheapest rented movie moviej was rented from the shop shopj. The movies in res should be sorted by price in ascending order, and in case of a tie, the one with the smaller shopj should appear first, and if there is still tie, the one with the smaller moviej should appear first. If there are fewer than 5 rented movies, then all of them should be returned. If no movies are currently being rented, then an empty list should be returned.

Implement the MovieRentingSystem class:

• MovieRentingSystem(int n, int[][] entries) Initializes the MovieRentingSystem object with n shops and the movies in entries.
• List<Integer> search(int movie) Returns a list of shops that have an unrented copy of the given movie as described above.
• void rent(int shop, int movie) Rents the given movie from the given shop.
• void drop(int shop, int movie) Drops off a previously rented movie at the given shop.
• List<List<Integer>> report() Returns a list of cheapest rented movies as described above.

Note: The test cases will be generated such that rent will only be called if the shop has an unrented copy of the movie, and drop will only be called if the shop had previously rented out the movie.

Example 1:

Input
["MovieRentingSystem", "search", "rent", "rent", "report", "drop", "search"]
[[3, [[0, 1, 5], [0, 2, 6], [0, 3, 7], [1, 1, 4], [1, 2, 7], [2, 1, 5]]], [1], [0, 1], [1, 2], [], [1, 2], [2]]
Output
[null, [1, 0, 2], null, null, [[0, 1], [1, 2]], null, [0, 1]]

Explanation
MovieRentingSystem movieRentingSystem = new MovieRentingSystem(3, [[0, 1, 5], [0, 2, 6], [0, 3, 7], [1, 1, 4], [1, 2, 7], [2, 1, 5]]);
movieRentingSystem.search(1);  // return [1, 0, 2], Movies of ID 1 are unrented at shops 1, 0, and 2. Shop 1 is cheapest; shop 0 and 2 are the same price, so order by shop number.
movieRentingSystem.rent(0, 1); // Rent movie 1 from shop 0. Unrented movies at shop 0 are now [2,3].
movieRentingSystem.rent(1, 2); // Rent movie 2 from shop 1. Unrented movies at shop 1 are now [1].
movieRentingSystem.report();   // return [[0, 1], [1, 2]]. Movie 1 from shop 0 is cheapest, followed by movie 2 from shop 1.
movieRentingSystem.drop(1, 2); // Drop off movie 2 at shop 1. Unrented movies at shop 1 are now [1,2].
movieRentingSystem.search(2);  // return [0, 1]. Movies of ID 2 are unrented at shops 0 and 1. Shop 0 is cheapest, followed by shop 1.

Constraints:

• 1 <= n <= 3 * 105
• 1 <= entries.length <= 105
• 0 <= shopi < n
• 1 <= moviei, pricei <= 104
• Each shop carries at most one copy of a movie moviei.
• At most 105 calls in total will be made to search, rent, drop and report.

Solution: Hashtable + TreeSet

We need three containers:
1. movies tracks the {movie -> price} of each shop. This is readonly to get the price of a movie for generating keys for treesets.
2. unrented tracks unrented movies keyed by movie id, value is a treeset ordered by {price, shop}.
3. rented tracks rented movies, a treeset ordered by {price, shop, movie}

Note: By using array<int, 3> we can unpack values like below:
array<int, 3> entries; // {price, shop, movie}
for (const auto [price, shop, moive] : entries)
…

Time complexity:
Init: O(nlogn)
rent / drop: O(logn)
search / report: O(1)

Space complexity: O(n)

// Author: Huahua
class MovieRentingSystem {
public:
  MovieRentingSystem(int n, vector<vector<int>>& entries): movies(n) {
    for (const auto& e : entries) {
      const int shop = e[0];
      const int movie = e[1];
      const int price = e[2];
      movies[shop].emplace(movie, price);
      unrented[movie].emplace(price, shop);
    }
  }

  vector<int> search(int movie) {
    vector<int> shops;
    for (const auto [price, shop] : unrented[movie]) {
      shops.push_back(shop);
      if (shops.size() == 5) break;
    }
    return shops;
  }

  void rent(int shop, int movie) {
    const int price = movies[shop][movie];
    unrented[movie].erase({price, shop});
    rented.insert({price, shop, movie});
  }

  void drop(int shop, int movie) {
    const int price = movies[shop][movie];
    rented.erase({price, shop, movie});
    unrented[movie].emplace(price, shop);
  }

  vector<vector<int>> report() {
    vector<vector<int>> ans;
    for (const auto& [price, shop, movie] : rented) {
      ans.push_back({shop, movie});
      if (ans.size() == 5) break;
    }
    return ans;
  }
private:
  vector<unordered_map<int, int>> movies; // shop -> {movie -> price}
  unordered_map<int, set<pair<int, int>>> unrented; // movie -> {price, shop}
  set<array<int, 3>> rented; // {price, shop, movie}
};

• For example, if chairs 0, 1, and 5 are occupied when a friend comes, they will sit on chair number 2.

When a friend leaves the party, their chair becomes unoccupied at the moment they leave. If another friend arrives at that same moment, they can sit in that chair.

You are given a 0-indexed 2D integer array times where times[i] = [arrivali, leavingi], indicating the arrival and leaving times of the ith friend respectively, and an integer targetFriend. All arrival times are distinct.

Return the chair number that the friend numbered targetFriend will sit on.

Example 1:

Input: times = [[1,4],[2,3],[4,6]], targetFriend = 1
Output: 1
Explanation: 
- Friend 0 arrives at time 1 and sits on chair 0.
- Friend 1 arrives at time 2 and sits on chair 1.
- Friend 1 leaves at time 3 and chair 1 becomes empty.
- Friend 0 leaves at time 4 and chair 0 becomes empty.
- Friend 2 arrives at time 4 and sits on chair 0.
Since friend 1 sat on chair 1, we return 1.

Example 2:

Input: times = [[3,10],[1,5],[2,6]], targetFriend = 0
Output: 2
Explanation: 
- Friend 1 arrives at time 1 and sits on chair 0.
- Friend 2 arrives at time 2 and sits on chair 1.
- Friend 0 arrives at time 3 and sits on chair 2.
- Friend 1 leaves at time 5 and chair 0 becomes empty.
- Friend 2 leaves at time 6 and chair 1 becomes empty.
- Friend 0 leaves at time 10 and chair 2 becomes empty.
Since friend 0 sat on chair 2, we return 2.

Constraints:

• n == times.length
• 2 <= n <= 104
• times[i].length == 2
• 1 <= arrivali < leavingi <= 105
• 0 <= targetFriend <= n - 1
• Each arrivali time is distinct.

Solution: Treeset + Simulation

Use a treeset to track available chairs, sort events by time.
note: process leaving events first.

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

// Author: Huahua
class Solution {
public:
  int smallestChair(vector<vector<int>>& times, int targetFriend) {
    const int n = times.size();
    vector<pair<int, int>> arrival(n);
    vector<pair<int, int>> leaving(n);
    for (int i = 0; i < n; ++i) {
      arrival[i] = {times[i][0], i};
      leaving[i] = {times[i][1], i};
    }
    vector<int> pos(n);
    iota(begin(pos), end(pos), 0); // pos = [0, 1, ..., n -1]
    set<int> aval(begin(pos), end(pos));    
    sort(begin(arrival), end(arrival));
    sort(begin(leaving), end(leaving));
    for (int i = 0, j = 0; i < n; ++i) {
      const auto [t, u] = arrival[i];
      while (j < n && leaving[j].first <= t)        
        aval.insert(pos[leaving[j++].second]);        
      aval.erase(pos[u] = *begin(aval));      
      if (u == targetFriend) return pos[u];
    }
    return -1;
  }
};

You are building a system that tracks the ranking of locations with the system initially starting with no locations. It supports:

• Adding scenic locations, one at a time.
• Querying the ith best location of all locations already added, where i is the number of times the system has been queried (including the current query).
  • For example, when the system is queried for the 4th time, it returns the 4th best location of all locations already added.

Note that the test data are generated so that at any time, the number of queries does not exceed the number of locations added to the system.

Implement the SORTracker class:

• SORTracker() Initializes the tracker system.
• void add(string name, int score) Adds a scenic location with name and score to the system.
• string get() Queries and returns the ith best location, where i is the number of times this method has been invoked (including this invocation).

Example 1:

<strong>Input</strong>
["SORTracker", "add", "add", "get", "add", "get", "add", "get", "add", "get", "add", "get", "get"]
[[], ["bradford", 2], ["branford", 3], [], ["alps", 2], [], ["orland", 2], [], ["orlando", 3], [], ["alpine", 2], [], []]
<strong>Output</strong>
[null, null, null, "branford", null, "alps", null, "bradford", null, "bradford", null, "bradford", "orland"]
<p><strong>Explanation</strong> 
SORTracker tracker = new SORTracker(); // Initialize the tracker system.
tracker.add("bradford", 2);            // Add location with name="bradford" and score=2 to the system.
tracker.add("branford", 3);            // Add location with name="branford" and score=3 to the system.
tracker.get();                         // The sorted locations, from best to worst, are: branford, bradford. 
                                       // Note that branford precedes bradford due to its <strong>higher score</strong> (3 &gt; 2). 
                                       // This is the 1<sup>st</sup> time get() is called, so return the best location: "branford". 
tracker.add("alps", 2);                // Add location with name="alps" and score=2 to the system.
tracker.get();                         // Sorted locations: branford, alps, bradford. 
                                       // Note that alps precedes bradford even though they have the same score (2). 
                                       // This is because "alps" is <strong>lexicographically smaller</strong> than "bradford". 
                                       // Return the 2<sup>nd</sup> best location "alps", as it is the 2<sup>nd</sup> time get() is called.
tracker.add("orland", 2);              // Add location with name="orland" and score=2 to the system.
tracker.get();                         // Sorted locations: branford, alps, bradford, orland. 
                                       // Return "bradford", as it is the 3<sup>rd</sup> time get() is called. 
tracker.add("orlando", 3);             // Add location with name="orlando" and score=3 to the system.
tracker.get();                         // Sorted locations: branford, orlando, alps, bradford, orland. 
                                       // Return "bradford". 
tracker.add("alpine", 2);              // Add location with name="alpine" and score=2 to the system.
tracker.get();                         // Sorted locations: branford, orlando, alpine, alps, bradford, orland. 
                                       // Return "bradford". 
tracker.get();                         // Sorted locations: branford, orlando, alpine, alps, bradford, orland. 
                                       // Return "orland".
</p>

Constraints:

• name consists of lowercase English letters, and is unique among all locations.
• 1 <= name.length <= 10
• 1 <= score <= 105
• At any time, the number of calls to get does not exceed the number of calls to add.
• At most 4 * 104 calls in total will be made to add and get.

Solution: TreeSet w/ Iterator

Use a treeset to store all the entries and use a iterator that points to the entry to return. When inserting a new entry into the tree, if it’s higher than the current element then let the iterator go backward one step.

Time complexity: add O(logn) / get O(1)

// Author: Huahua
class SORTracker {
public:
  SORTracker() {}

  void add(string name, int score) {    
    if (*s.emplace(-score, name).first < *cit) --cit;
  }

  string get() {
    return (cit++)->second;
  }
private:
  set<pair<int, string>> s;
  // Note: cit points to begin(s) after first insertion.
  set<pair<int, string>>::const_iterator cit = end(s);
};

Given an array changed, return original if changed is a doubled array. If changed is not a doubled array, return an empty array. The elements in original may be returned in any order.

Example 1:

Input: changed = [1,3,4,2,6,8]
Output: [1,3,4]
Explanation: One possible original array could be [1,3,4]:
- Twice the value of 1 is 1 * 2 = 2.
- Twice the value of 3 is 3 * 2 = 6.
- Twice the value of 4 is 4 * 2 = 8.
Other original arrays could be [4,3,1] or [3,1,4].

Example 2:

Input: changed = [6,3,0,1]
Output: []
Explanation: changed is not a doubled array.

Example 3:

Input: changed = [1]
Output: []
Explanation: changed is not a doubled array.

Constraints:

• 1 <= changed.length <= 105
• 0 <= changed[i] <= 105

Solution 1: Multiset

Start from the smallest number x, erase one x * 2 from the set.

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

// Author: Huahua
class Solution {
public:
  vector<int> findOriginalArray(vector<int>& changed) {
    if (changed.size() & 1) return {};
    const int n = changed.size() / 2;
    multiset<int> s(begin(changed), end(changed));    
    while (ans.size() != n) {
      int o = *begin(s);
      s.erase(begin(s));
      ans.push_back(o);
      auto it = s.find(o * 2);
      if (it == end(s)) return {};
      s.erase(it);
    }
    return ans;
  }
};

Solution 2: Hashtable

Time complexity: O(max(nums) + n)
Space complexity: O(max(nums))

// Author: Huahua
class Solution {
public:
  vector<int> findOriginalArray(vector<int>& changed) {
    if (changed.size() & 1) return {};
    const int n = changed.size() / 2;
    const int kMax = *max_element(begin(changed), end(changed));
    vector<int> m(kMax + 1);
    for (int x : changed) ++m[x];
    if (m[0] & 1) return {};
    vector<int> ans(m[0] / 2, 0);
    for (int x = 1; ans.size() != n; ++x) {
      if (x * 2 > kMax || m[x * 2] < m[x]) return {};      
      ans.insert(end(ans), m[x], x);
      m[x * 2] -= m[x];   
    }
    return ans;
  }
};

Implement the SeatManager class:

• SeatManager(int n) Initializes a SeatManager object that will manage n seats numbered from 1 to n. All seats are initially available.
• int reserve() Fetches the smallest-numbered unreserved seat, reserves it, and returns its number.
• void unreserve(int seatNumber) Unreserves the seat with the given seatNumber.

Example 1:

Input
["SeatManager", "reserve", "reserve", "unreserve", "reserve", "reserve", "reserve", "reserve", "unreserve"]
[[5], [], [], [2], [], [], [], [], [5]]
Output

[null, 1, 2, null, 2, 3, 4, 5, null]

Explanation SeatManager seatManager = new SeatManager(5); // Initializes a SeatManager with 5 seats. seatManager.reserve(); // All seats are available, so return the lowest numbered seat, which is 1. seatManager.reserve(); // The available seats are [2,3,4,5], so return the lowest of them, which is 2. seatManager.unreserve(2); // Unreserve seat 2, so now the available seats are [2,3,4,5]. seatManager.reserve(); // The available seats are [2,3,4,5], so return the lowest of them, which is 2. seatManager.reserve(); // The available seats are [3,4,5], so return the lowest of them, which is 3. seatManager.reserve(); // The available seats are [4,5], so return the lowest of them, which is 4. seatManager.reserve(); // The only available seat is seat 5, so return 5. seatManager.unreserve(5); // Unreserve seat 5, so now the available seats are [5].

Constraints:

• 1 <= n <= 105
• 1 <= seatNumber <= n
• For each call to reserve, it is guaranteed that there will be at least one unreserved seat.
• For each call to unreserve, it is guaranteed that seatNumber will be reserved.
• At most 105 calls in total will be made to reserve and unreserve.

Solution: TreeSet

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

// Author: Huahua
class SeatManager {
public:
  SeatManager(int n) {
    for (int i = 1; i <= n; ++i)
      s_.insert(i);
  }

  int reserve() {    
    int seat = *begin(s_);
    s_.erase(begin(s_));    
    return seat;
  }

  void unreserve(int seatNumber) {
    s_.insert(seatNumber);    
  }
private:
  set<int> s_;
};

You are given an array nums of n positive integers.

You can perform two types of operations on any element of the array any number of times:

• If the element is even, divide it by 2.
  • For example, if the array is [1,2,3,4], then you can do this operation on the last element, and the array will be [1,2,3,2].
• If the element is odd, multiply it by 2.
  • For example, if the array is [1,2,3,4], then you can do this operation on the first element, and the array will be [2,2,3,4].

The deviation of the array is the maximum difference between any two elements in the array.

Return the minimum deviation the array can have after performing some number of operations.

Example 1:

Input: nums = [1,2,3,4]
Output: 1
Explanation: You can transform the array to [1,2,3,2], then to [2,2,3,2], then the deviation will be 3 - 2 = 1.

Example 2:

Input: nums = [4,1,5,20,3]
Output: 3
Explanation: You can transform the array after two operations to [4,2,5,5,3], then the deviation will be 5 - 2 = 3.

Example 3:

Input: nums = [2,10,8]
Output: 3

Constraints:

• n == nums.length
• 2 <= n <= 105
• 1 <= nums[i] <= 109

Solution: Priority Queue

If we double an odd number it becomes an even number, then we can only divide it by two which gives us back the original number. So we can pre-double all the odd numbers and only do division in the following process.

We push all numbers including pre-doubled odd ones onto a priority queue, and track the difference between the largest and smallest number.

Each time, we pop the largest number out and divide it by two then put it back to the priority queue, until the largest number becomes odd. We can not discard it and divide any other smaller numbers by two will only increase the max difference, so we can stop here.

ex1: [3, 5, 8] => [6, 8, 10] (pre-double) => [5, 6, 8] => [4, 5, 6] => [3, 4, 5] max diff is 5 – 3 = 2
ex2: [4,1,5,20,3] => [2, 4, 6, 10, 20] (pre-double) => [2, 4, 6, 10] => [2, 4, 5, 6] => [2,3,4,5] max diff = 5-2 = 3

Time complexity: O(n*logm*logn)
Space complexity: O(n)

class Solution {
public:
  int minimumDeviation(vector<int>& nums) {
    set<int> s;
    for (int x : nums)
      s.insert(x & 1 ? x * 2 : x);
    int ans = *rbegin(s) - *begin(s);
    while (*rbegin(s) % 2 == 0) {
      s.insert(*rbegin(s) / 2);
      s.erase(*rbegin(s));
      ans = min(ans, *rbegin(s) - *begin(s));
    }
    return ans;
  }
};

class Solution {
public:
  int minimumDeviation(vector<int>& nums) {
    priority_queue<int> q;    
    int lo = INT_MAX;
    for (int x : nums) {
      x = x & 1 ? x * 2 : x;
      q.push(x);
      lo = min(lo, x);
    }
    int ans = q.top() - lo;
    while (q.top() % 2 == 0) {
      int x = q.top(); q.pop();
      q.push(x / 2);
      lo = min(lo, x / 2);
      ans = min(ans, q.top() - lo);
    }
    return ans;
  }
};

You have k servers numbered from 0 to k-1 that are being used to handle multiple requests simultaneously. Each server has infinite computational capacity but cannot handle more than one request at a time. The requests are assigned to servers according to a specific algorithm:

• The ith (0-indexed) request arrives.
• If all servers are busy, the request is dropped (not handled at all).
• If the (i % k)th server is available, assign the request to that server.
• Otherwise, assign the request to the next available server (wrapping around the list of servers and starting from 0 if necessary). For example, if the ith server is busy, try to assign the request to the (i+1)th server, then the (i+2)th server, and so on.

You are given a strictly increasing array arrival of positive integers, where arrival[i] represents the arrival time of the ith request, and another array load, where load[i] represents the load of the ith request (the time it takes to complete). Your goal is to find the busiest server(s). A server is considered busiest if it handled the most number of requests successfully among all the servers.

Return a list containing the IDs (0-indexed) of the busiest server(s). You may return the IDs in any order.

Example 1:

Input: k = 3, arrival = [1,2,3,4,5], load = [5,2,3,3,3] 
Output: [1] 
Explanation:
All of the servers start out available.
The first 3 requests are handled by the first 3 servers in order.
Request 3 comes in. Server 0 is busy, so it's assigned to the next available server, which is 1.
Request 4 comes in. It cannot be handled since all servers are busy, so it is dropped.
Servers 0 and 2 handled one request each, while server 1 handled two requests. Hence server 1 is the busiest server.

Example 2:

Input: k = 3, arrival = [1,2,3,4], load = [1,2,1,2]
Output: [0]
Explanation:
The first 3 requests are handled by first 3 servers.
Request 3 comes in. It is handled by server 0 since the server is available.
Server 0 handled two requests, while servers 1 and 2 handled one request each. Hence server 0 is the busiest server.

Example 3:

Input: k = 3, arrival = [1,2,3], load = [10,12,11]
Output: [0,1,2]
Explanation: Each server handles a single request, so they are all considered the busiest.

Example 4:

Input: k = 3, arrival = [1,2,3,4,8,9,10], load = [5,2,10,3,1,2,2]
Output: [1]

Example 5:

Input: k = 1, arrival = [1], load = [1]
Output: [0]

Constraints:

• 1 <= k <= 105
• 1 <= arrival.length, load.length <= 105
• arrival.length == load.length
• 1 <= arrival[i], load[i] <= 109
• arrival is strictly increasing.

Solution: Heap + TreeSet

Use a min heap to store the release time -> server.
Use a treeset to track the current available servers.
For reach request, check whether servers can be released at that time.

Time complexity: O(nlogk)
Space complexity: O(k)

// Author: Huahua
class Solution {
public:
  vector<int> busiestServers(int k, vector<int>& arrival, vector<int>& load) {
    priority_queue<pair<int, int>, vector<pair<int,int>>, greater<>> q; // {release_time, server}
    set<int> servers;
    vector<int> requests(k);
    
    for (int i = 0; i < k; ++i)
      servers.insert(i);
    
    for (int i = 0; i < arrival.size(); ++i) {
      const int t = arrival[i];
      const int l = load[i];
      
      // Release servers. O(logk) per pop()
      while (!q.empty() && q.top().first <= t) {        
        servers.insert(q.top().second);  
        q.pop();
      }
      
      // Drop the request.
      if (servers.empty()) continue;
      
      // Find first avaiable one O(logk)
      auto it = servers.lower_bound(i % k);
      if (it == servers.end()) it = begin(servers);
      const int idx = *it;
      
      ++requests[idx];
      servers.erase(it);
      q.emplace(t + l, idx);
    }
    const int max_req = *max_element(begin(requests), end(requests));
    vector<int> ans;
    for (int i = 0; i < k; ++i)
      if (requests[i] == max_req) ans.push_back(i);
    return ans;
  }
};