A Busiest Computing Nodes
You have a computing cluster with a total of k computing nodes, labelled from 0 to k−1. The cluster can handle multiple requests at the same time, but each node can process at most one request at the same time.
The rules for request assignment to computing nodes are as follows. Assume the i-th (i starts from 0) request arrives. If all nodes are occupied, the request is discarded (not processed at all). If the (i%k)-th node is available, it will process the request. Otherwise, the request will check the availability of the next node at (i+1)%k, (i+2)%k, and so on, until it finds an idle node.
Given a set of requests with their arrival time and the processing time, your task is to find the busiest computing nodes. A node that belongs to the busiest nodes when no other nodes serve more requests than it does.
Input
The first line includes k and n, representing the size of the cluster and the number of requests.
Each of the next n lines includes two positive integers, representing the arrival time and the processing time of a request.
The input data satisfy that 1≤k,n≤100,000, and 1≤arrival_time,processing_time≤1,000,000,000.
The requests are given in non-decreasing order of arrival time.
Output
Print the labels of all the busiest nodes in lexicographic numerical order, separated by spaces.
Sample Input
3 5
1 5
2 2
3 3
4 3
5 3
结尾无空行
Sample Output
1
结尾无空行
- 题意：某系统有k个内存块，用户提出了n个请求，每个内存块每次只能处理一个请求。如果某个请求到达时，所有内存块都被占用，则该请求被忽略（永不被执行），否则将该请求交给某个内存块处理（从i%k，(i+1)%k ，个块依次循环向右查找第一个空闲的块，然后把当前请求提交给这个块）。试求处理请求最多的内存块号。
思路一：可以用线段树维护区间最值，然后通过二分区间来确定可被选用的块号。二分过程可写在线段树内部，也可以卸载线段树外部。在线段树外部的二分更容易理解，但复杂度略高。
code （线段树 + 二分）
时间复杂度约为O(nlgklgk)。
#include <iostream>
#include <vector>
#define int long long
using namespace std ;
const int N = 1e5+10 ;
const int INF = 5e18;
int tr[N*4] ;
int a[N] ;
int b[N] ;
int c[N] ;
int k , n ;
int vis[N] ;
vector<int>ans ;
void build(int u , int l , int r){
if(l == r){
tr[u] = c[l];
}else{
int mid = (l + r) >> 1 ;
build (u << 1 , l , mid) ;
build (u << 1 | 1 , mid+1 , r) ;
tr[u] = min (tr[u << 1] , tr[u << 1 | 1]) ;
}
}
void update(int u , int l , int r , int pos , int val)
{
if(l == r){
tr[u] = val ;
c[l] = val ;
}else {
int mid = (l + r) >> 1 ;
if(pos <= mid) update (u << 1 , l , mid , pos , val) ;
else update (u << 1 | 1 , mid + 1 , r , pos , val) ;
tr[u] = min(tr[u << 1] , tr[u << 1 | 1]);
}
}
int query(int u , int l , int r , int L , int R)
{
if(L <= l && r <= R){
return tr[u] ;
}else {
int mid = (l + r) >> 1 ;
int re = INF ;
if(mid >= L){
re = min (re , query(u << 1 , l , mid , L , R)) ;
}
if(mid + 1 <= R){
re = min (re , query(u << 1 | 1 , mid + 1 , r , L , R)) ;
}
return re ;
}
}
int BSearch(int L , int R , int val)
{
int l = L , r = R ;
int mid = (l + r) >> 1 ;
while(l != r) {
if(query(1,0,k-1,l,mid)<=val){
r = mid ;
}
else if(query(1,0,k-1,mid+1,r)<=val){
l = mid + 1;
}
else{
return -1;
}
mid = (l + r) >> 1 ;
}
return c[l] <= val ? l : -1 ;
}
signed main()
{
//freopen("in","r",stdin);
scanf("%lld%lld",&k,&n) ;
for(int i = 0 ; i < n * 4 ; i++) tr[i] = INF ;
for(int i = 0 ; i < n; i++){
scanf("%lld%lld",&a[i],&b[i]) ;
c[i] = a[i] + b[i] ;
}
build(1,0,k-1);
for(int i = k ; i < n ; i++){
int stime = a[i] ;
int ftime = a[i] + b[i] ;
int l1 , r1 , l2 , r2 ;
l1 = i % k , r1 = k - 1 ;
l2 = 0 , r2 = i % k - 1 ;
int idx1 = -1, idx2 = -1;
if(l1 <= r1) idx1 = BSearch(l1,r1,stime) ;
if(l2 <= r2 && idx1 == -1) idx2 = BSearch(l2,r2,stime) ;
if(idx1!=-1){
vis[idx1]++;
update(1,0,k-1,idx1,ftime);
}else if(idx2!=-1){
vis[idx2]++;
update(1,0,k-1,idx2,ftime);
}else{
continue ;
}
}
int Maxx = 0 ;
for(int i = 0 ; i < k ; i++){
if(vis[i] > Maxx) Maxx = vis[i] ;
}
for(int i = 0 ; i < k ; i++){
if(vis[i] == Maxx) ans.push_back(i) ;
}
for(int i = 0 ; i < ans.size() ; i++){
if(i) printf(" ");
printf("%lld",ans[i]) ;
}
return 0 ;
}
利用线段树特有性质直接内部二分
时间复杂度约为O(n*logk)。
code：
#include <iostream>
#include <vector>
#define int long long
using namespace std ;
const int N = 1e5+10 ;
const int INF = 5e18;
int tr[N*4] ;
int a[N] ;
int b[N] ;
int c[N] ;
int k , n ;
int vis[N] ;
vector<int>ans ;
void build(int u , int l , int r){
if(l == r){
tr[u] = c[l];
}else{
int mid = (l + r) >> 1 ;
build (u << 1 , l , mid) ;
build (u << 1 | 1 , mid+1 , r) ;
tr[u] = min (tr[u << 1] , tr[u << 1 | 1]) ;
}
}
void update(int u , int l , int r , int pos , int val)
{
if(l == r){
tr[u] = val ;
c[l] = val ;
}else {
int mid = (l + r) >> 1 ;
if(pos <= mid) update (u << 1 , l , mid , pos , val) ;
else update (u << 1 | 1 , mid + 1 , r , pos , val) ;
tr[u] = min(tr[u << 1] , tr[u << 1 | 1]);
}
}
int query(int u , int l , int r , int L , int R , int val)
{
if(l == r){
return l;
}else {
int mid = (l + r) >> 1 ;
int ans1 = INF , ans2 = INF;
if(mid >= L && tr[u << 1] <= val)
ans1 = query(u << 1 , l , mid , L , R ,val) ;
if(ans1 == INF && mid + 1 <= R && tr[u << 1 | 1] <= val )
ans2 = query(u << 1 | 1 , mid + 1 , r , L , R ,val);
return min(ans1,ans2);
}
}
int BSearch(int L , int R , int val)
{
return query(1,0,k-1,L,R,val);
}
signed main()
{
//freopen("in","r",stdin);
scanf("%lld%lld",&k,&n) ;
for(int i = 0 ; i < n * 4 ; i++) tr[i] = INF ;
for(int i = 0 ; i < n; i++){
scanf("%lld%lld",&a[i],&b[i]) ;
c[i] = a[i] + b[i] ;
}
build(1,0,k-1);
for(int i = k ; i < n ; i++){
int stime = a[i] ;
int ftime = a[i] + b[i] ;
int l1 , r1 , l2 , r2 ;
l1 = i % k , r1 = k - 1 ;
l2 = 0 , r2 = i % k - 1;
int idx1 = INF, idx2 = INF;
if(l1 <= r1) idx1 = BSearch(l1,r1,stime) ;
if(l2 <= r2 && idx1 == INF) idx2 = BSearch(l2,r2,stime) ;
if(idx1 != INF){
vis[idx1]++;
update(1,0,k-1,idx1,ftime);
}else if(idx2 != INF){
vis[idx2]++;
update(1,0,k-1,idx2,ftime);
}else{
continue ;
}
}
int Maxx = 0 ;
for(int i = 0 ; i < k ; i++){
if(vis[i] > Maxx) Maxx = vis[i] ;
}
for(int i = 0 ; i < k ; i++){
if(vis[i] == Maxx) ans.push_back(i) ;
}
for(int i = 0 ; i < ans.size() ; i++){
if(i) printf(" ");
printf("%lld",ans[i]) ;
}
return 0 ;
}
思路二：可以用一个堆来维护被占用的块号和块的被释放时间，用另一个堆维护未被占用的块号。这样只需要同时维护两个小根堆，每次查找时，在空闲块堆中找某个数的后继或者堆中最小值。
#include <bits/stdc++.h>
#define int long long
using namespace std ;
const int N = 1e5 + 10 ;
struct Node{
int id , ftime ;
bool operator < (const Node no1) const {
if(ftime != no1.ftime) return ftime < no1.ftime ;
else return id < no1.id ;
}
} ;
set<int>v ;
set<Node>u ;
int a[N] , b[N] ;
int vis[N] ;
int n , k ;
signed main()
{
scanf("%d%d",&k,&n);
int MMax = 0 ;
for(int i = 0 ; i < n ; i++) scanf("%lld%lld",&a[i],&b[i]) ;
for(int i = 0 ; i < min(n,k) ; i++){
vis[i]++;
MMax = max(MMax , vis[i]) ;
u.insert({i,a[i]+b[i]});
}
for(int i = k ; i < n ; i++){
while(!u.empty()){
Node top = *u.begin();
if(top.ftime <= a[i]){
v.insert(top.id) ;
u.erase(u.begin());
}else{
break;
}
}
int d = i % k ;
if(v.empty())continue;
auto it = v.lower_bound(d);
if(it == v.end()) it = v.begin() ;
vis[*it]++;
MMax = max(MMax , vis[*it]);
u.insert({*it,a[i]+b[i]});
v.erase(it);
}
vector<int>ans;
for(int i = 0 ; i < k ; i++){
if(vis[i] == MMax) ans.push_back(i) ;
}
for(int i = 0 ; i < ans.size() ; i++){
if(i) printf(" ");
printf("%lld",ans[i]);
}
return 0 ;
}
找后继或者最小值的操作也可以借助 “树状数组+二分查找” 实现
code：
#include <iostream>
#include <set>
#include <vector>
const int N = 1e5+10 ;
using namespace std ;
struct Node{
long long int ftime ;
int id ;
bool operator < (const Node no1) const{
if(ftime!=no1.ftime)return ftime < no1.ftime ;
else return id < no1.id ;
}
};
set<Node>st ;
int C[N] ;
int k , n ;
int a[N] , b[N] ;
int vis[N] ;
vector<int>ans ;
int ask(int R)
{
if(!R) return R ;
else return C[R] + ask(R - (R & -R)) ;
}
void add(int R , int val)
{
if(R > N)return ;
else C[R] += val , add(R + (R & -R), val) ;
}
int getnext(int x)
{
int l = x , r = k;
while(l + 1 < r)
{
int mid = (l + r) / 2 ;
if(ask(mid)- ask(l-1) > 0) r = mid ;
else if(ask(r) - ask(l-1) > 0) l = mid ;
else return -1 ;
}
if(ask(l)- ask(l-1) > 0) return l ;
else if(ask(r) - ask(r-1) > 0) return r ;
else return -1;
}
int getmin()
{
int l = 1 , r = k ;
while(l + 1 < r)
{
int mid = (l + r) / 2 ;
if(ask(mid) > 0) r = mid ;
else l = mid ;
}
if(ask(l) > 0) return l ;
else if (ask(r) > 0) return r ;
else return -1 ;
}
int main()
{
scanf("%d%d",&k,&n);
for(int i = 0 ; i < n ; i++) {
scanf("%d%d",&a[i],&b[i]);
}
int MAXS = 0 ;
for(int i = 0 ; i < min(k,n) ; i++){
st.insert({a[i]+b[i] , i}) ;
vis[i]++;
MAXS = max(MAXS , vis[i]) ;
}
for(int i = k ; i < n ; i++){
long long int stime = a[i] , ftime = a[i] + b[i] ;
while(!st.empty() && (*st.begin()).ftime <= stime){
add((*st.begin()).id + 1,1);
st.erase(st.begin());
}
int t = i % k;
int Min ;
int nxt = getnext(t+1) ;
if(nxt!=-1){
add(nxt,-1);
vis[nxt - 1]++;
MAXS = max(vis[nxt - 1] , MAXS) ;
st.insert({ftime,nxt - 1}) ;
}else{
Min = getmin() ;
if(Min != -1){
vis[Min - 1] ++ ;
MAXS = max(vis[Min - 1] , MAXS) ;
add(Min,-1);
st.insert({ftime,Min - 1});
}
}
}
for(int i = 0 ; i < n ; i++) {
if(vis[i] == MAXS) ans.push_back(i) ;
}
for(int i = 0 ; i < ans.size() ; i++){
if(i) putchar(' ');
printf("%d",ans[i]) ;
}
return 0 ;
}
扫一扫
114
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
