PAT(甲级)1026

1026. Table Tennis (30)

时间限制

400 ms

内存限制

65536 kB

代码长度限制

16000 B

判题程序

Standard

作者

CHEN, Yue

A table tennis club has N tables available to the public. The tables are numbered from 1 to N. For any pair of players, if there are some tables open when they arrive, they will be assigned to the available table with the smallest number. If all the tables
are occupied, they will have to wait in a queue. It is assumed that every pair of players can play for at most 2 hours.

Your job is to count for everyone in queue their waiting time, and for each table the number of players it has served for the day.

One thing that makes this procedure a bit complicated is that the club reserves some tables for their VIP members. When a VIP table is open, the first VIP pair in the queue will have the priviledge to take it. However, if there is no VIP in the queue, the next
pair of players can take it. On the other hand, if when it is the turn of a VIP pair, yet no VIP table is available, they can be assigned as any ordinary players.

Input Specification:

Each input file contains one test case. For each case, the first line contains an integer N (<=10000) - the total number of pairs of players. Then N lines follow, each contains 2 times and a VIP tag: HH:MM:SS - the arriving time, P - the playing time in minutes
of a pair of players, and tag - which is 1 if they hold a VIP card, or 0 if not. It is guaranteed that the arriving time is between 08:00:00 and 21:00:00 while the club is open. It is assumed that no two customers arrives at the same time. Following the players'
info, there are 2 positive integers: K (<=100) - the number of tables, and M (< K) - the number of VIP tables. The last line contains M table numbers.

Output Specification:

For each test case, first print the arriving time, serving time and the waiting time for each pair of players in the format shown by the sample. Then print in a line the number of players served by each table. Notice that the output must be listed in chronological
order of the serving time. The waiting time must be rounded up to an integer minute(s). If one cannot get a table before the closing time, their information must NOT be printed.
Sample Input:

9
20:52:00 10 0
08:00:00 20 0
08:02:00 30 0
20:51:00 10 0
08:10:00 5 0
08:12:00 10 1
20:50:00 10 0
08:01:30 15 1
20:53:00 10 1
3 1
2

Sample Output:

08:00:00 08:00:00 0
08:01:30 08:01:30 0
08:02:00 08:02:00 0
08:12:00 08:16:30 5
08:10:00 08:20:00 10
20:50:00 20:50:00 0
20:51:00 20:51:00 0
20:52:00 20:52:00 0

3 3 2
在网上找了转载了一部分坑，大家可以参考下：
题意自己理解了，主要是两个队列维护，一个VIP队列，一个普通队列

搜集了一些坑（有些坑转自别的网站用于广大同学的测试之用）

 

普通人也有VIP的权益！！！ 屌丝逆袭有木有！！！

9
20:52:00 10 0
08:00:00 20 0
08:02:00 30 0
20:51:00 10 0
08:10:00 5 0
08:12:00 10 1
20:50:00 10 0
08:01:30 15 1
20:53:00 10 1
10 10
1 2 3 4 5 6 7 8 9 10

08:00:00 08:00:00 0
08:01:30 08:01:30 0
08:02:00 08:02:00 0
08:10:00 08:10:00 0
08:12:00 08:12:00 0
20:50:00 20:50:00 0
20:51:00 20:51:00 0
20:52:00 20:52:00 0
20:53:00 20:53:00 0
2 2 2 2 1 0 0 0 0 0

 

1.当有多个乒乓球台空闲时，vip顾客到了会使用最小id的vip球台，而不是最小id的球台，测试以下用例：

2
10:00:00 30 1
12:00:00 30 1
5 1
3
输出正确结果应为：
10:00:00 10:00:00 0
12:00:00 12:00:00 0
0 0 2 0 0
 
2.题目要求每对顾客玩的时间不超过2小时，那么当顾客要求玩的时间>2小时的时候，应该截断控制，测试以下用例：
2
18:00:00 180 1
20:00:00 60 1
1 1
1
输出的正确结果应为：
18:00:00 18:00:00 0
20:00:00 20:00:00 0
2
3.虽然题目中保证客户到达时间在08:00:00到21:00:00之间，但是根据最后的8个case来看，里面还是有不在这个时间区间内到达的顾客，所以建议还是稍加控制，测试以下用例：
1
21:00:00 80 1
1 1
1
输出的正确结果应为：
0
4.题目中说的round up to an integer minutes是严格的四舍五入，需要如下做：
wtime = (stime - atime + 30) / 60
而不是：
wtime = (stime - atime + 59) / 60

下面是我的代码
#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;
const int SIZE=10004;
const int NUMOFTABLE = 101;
const int LIMIT = 75600; //21*60*60
struct Table{
Table(){
leave = 28800; //8*60*60
cnt =0;
tag = false;
}
int leave;
int cnt;
bool tag;
}tables[NUMOFTABLE];

struct Person{
Person(){
arrive =0;
service=75601;
wait =0;
process =0;
isvip =false;
process_flag = false;
}
int arrive;
int service;
int wait;
int process;
bool isvip,process_flag;
}persons[SIZE];

bool cmp(const Person &p1,const Person &p2){
return p1.arrive < p2.arrive;
}

bool cmp1(const Person &p1,const Person &p2){
return p1.service < p2.service;
}
/////////////////////////////////////////////////
// there is no empty tables here ,wait and choose the
// right table
////////////////////////////////////////////////////
int assign_table(int pid,int tnum,bool flag){
int index = 1;
for(int i=2;i<=tnum;i++) //first empty table
if(tables[index].leave > tables[i].leave)
index =i;
return index;
}
////////////////////////////////////////////////////////////////
//if there is empty table, find the correct number,else call
//find_table1 to choose the table which will be first empty
//////////////////////////////////////////////////////////////
int find_table(int pid,int tnum,bool flag){
int index=0,time;
time = persons[pid].arrive > 28800 ? persons[pid].arrive:28800; // incase someone come earlier than 8:00
if(flag) { //it is a vip member
int i=1;
for(;i<=tnum;i++){
if(tables[i].tag && time >= tables[i].leave){
return i;
}
}
}
for(int i=1;i<=tnum;i++){
if(time >= tables[i].leave){
index =i;
break;
}
}
return index; // if index =0, it indicates that there is no empty table when the member comes
}

int find_person(int pid,int n,int tid){
int time = tables[tid].leave;
for(int i= pid;i<=n&& persons[i].arrive<=time;i++)
if(persons[i].isvip && !persons[i].process_flag){
persons[i].process_flag= true;
pid = i;
break;
}
return pid;
}

void display(int n,int k){
for(int i=1;i<=n;i++){
int time2 = persons[i].service;
int time1 = persons[i].arrive;
if(time2 < 75600){//time2 <75600
int hour1,min1,sec1,hour2,min2,sec2;
hour1 = time1/3600;
min1 = (time1/60)%60;
sec1 = time1 %60;
hour2 = time2/3600;
min2 = (time2/60)%60;
sec2 = time2 %60;
printf("%02d:%02d:%02d %02d:%02d:%02d %d\n",hour1,min1,sec1,hour2,min2,sec2,persons[i].wait);
}else
break;
}
for(int i=1;i<k;i++)
printf("%d ",tables[i].cnt);
printf("%d\n",tables[k].cnt);
}

int main(){
int N,K,M;
// freopen("test.txt","r",stdin);
scanf("%d",&N);
for(int i=1;i<=N;i++){
int hour,min,sec,p,tag;
scanf("%02d:%02d:%02d%d%d",&hour,&min,&sec,&p,&tag);
persons[i].arrive = (hour*60+min)*60+sec;
persons[i].process = p*60 > 7200? 7200:p*60; //limit to 2 hours
if(tag)
persons[i].isvip = true;
}
scanf("%d%d",&K,&M);
for(int i=1;i<=M;i++){
int t;
scanf("%d",&t);
tables[t].tag = true;
}
sort(persons+1,persons+N+1,cmp); //take care of the boundary of sort [a,b)
// display(N,K);
int i,count=0;
for(i=1;i<=N;i++){
if(persons[i].arrive >= 75600) //the club is closed
break;
if(persons[i].process_flag) //ignore processed vip member
continue;
int tid = find_table(i,K,persons[i].isvip);
int pid =i;
if(tid){ //no wait needed
persons[pid].service = persons[pid].arrive > 28800 ? persons[pid].arrive:28800; //in case someone comes earlier than 8:00
tables[tid].cnt++;
tables[tid].leave = persons[pid].service + persons[pid].process;
persons[pid].process_flag = true;
continue;
} else{
tid = assign_table(i,K,persons[i].isvip);
if(tables[tid].leave >= 75600) //the club is closed when it is his turn
break;
if(tables[tid].tag && !persons[pid].isvip){
pid = find_person(pid,N,tid);
}
tables[tid].cnt++;
persons[pid].service = tables[tid].leave;
tables[tid].leave += persons[pid].process;
persons[pid].wait = persons[pid].service - persons[pid].arrive;
persons[pid].process_flag = true;
persons[pid].wait = (persons[pid].wait + 30)/60;
if(pid != i)
i--;
}
}
sort(persons+1,persons+N+1,cmp1);
display(N,K);

return 0;
}