74 lines
2.6 KiB
C++
74 lines
2.6 KiB
C++
#include <vector>
|
|
#include <set>
|
|
#include <queue>
|
|
#include <iostream>
|
|
|
|
/**
|
|
* 1606. Find Servers That Handled Most Number of Requests
|
|
* 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.
|
|
*/
|
|
|
|
class Solution {
|
|
public:
|
|
static std::vector<int> busiestServers(int k, const std::vector<int>& arrival, const std::vector<int>& load) {
|
|
int n = arrival.size();
|
|
|
|
std::set<int> pool;
|
|
|
|
// pair [nextFinish, id]
|
|
std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int>>, std::greater<>> q;
|
|
|
|
// Load time
|
|
std::vector<int> cnt(k);
|
|
|
|
// Initially, all server are available.
|
|
for (int i = 0; i < k; ++i)
|
|
pool.insert(i);
|
|
|
|
// Simulate over time...
|
|
for (int i = 0; i < n; ++i) {
|
|
int t = arrival[i];
|
|
|
|
// Pop any finished tasks, then put them into the pool.
|
|
while (!q.empty() && q.top().first <= t) {
|
|
pool.insert(q.top().second);
|
|
q.pop();
|
|
}
|
|
|
|
// If no available, ignore this task.
|
|
if (pool.empty())
|
|
continue;
|
|
|
|
// Find the server to use.
|
|
auto it = pool.lower_bound(i % k);
|
|
if (it == pool.end())
|
|
it = pool.begin();
|
|
|
|
// Record the usage
|
|
++cnt[*it];
|
|
q.push({t + load[i], *it});
|
|
pool.erase(it);
|
|
}
|
|
|
|
int m = *std::max_element(cnt.begin(), cnt.end());
|
|
std::vector<int> ret;
|
|
for (int i = 0; i < k; ++i)
|
|
if (m == cnt[i])
|
|
ret.push_back(i);
|
|
return ret;
|
|
}
|
|
};
|
|
|
|
int main() {
|
|
std::vector<int> ret = Solution::busiestServers(3, {1, 2, 3, 4, 5}, {5, 2, 3, 3, 3});
|
|
for (int i : ret)
|
|
std::cout << i << ' ';
|
|
return 0;
|
|
}
|