1026 Table Tennis

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

题意：

　　乒乓球俱乐部中有N张空闲的桌子，players来到后总是选择编号较小的桌子来进行练习，如果没有空闲的桌子可以使用，则需要排队等候，players能够使用桌子的最大时长为两小时。比较复杂的是，在这N张桌子中设置了m张专属于vip的桌子，如果等候队列中存在vip players，并且有空闲的vip table，则选择最前面的vip players使用vip table。如果队列中有vip players但是没有空闲的vip table则将vip players当做ordianry players来看待。

　　给出每一组players的到达时间和使用时间，问在club的营业时间中每一组players的到达时间，开始时间，以及等待时间。并输出每个桌子的服务人数。

思路：

　　模拟。构造两个结构体用来保存player和table的信息。将题目中的时间格式都化为second的形式来进行存储。解题的过程中用到了两个辅助函数update()和findNextVip()，第一个是用来更新player的开始时间以及当前player使用桌子的结束时间，第二个是用来寻找下一个到达的vip player的序号。将所有的用户根据到达时间进行排序。找到最早空闲出的table然后分别讨论这张桌子是不是vip table，然后再分别讨论当前的player是不是vip player根据不同的结果分别做不同的处理操作。

Code：

#include <bits/stdc++.h>

using namespace std;

const int inf = 0x7fffffff;

int n, m, k, t;

struct Player {
    int arriving_time;
    int starting_time = inf;
    int playing_time;
    int isVip;
} players[10005];

struct Table {
    int count = 0;
    int end = 8 * 3600;
    int isVip = 0;
} tables[105];

int parse(string str) {
    int hh = stoi(str.substr(0, 2));
    int mm = stoi(str.substr(3, 2));
    int ss = stoi(str.substr(6, 2));
    return hh * 3600 + mm * 60 + ss;
}

bool cmp1(Player a, Player b) { return a.arriving_time < b.arriving_time; }
bool cmp2(Player a, Player b) { return a.starting_time < b.starting_time; }

// 更新player的开始时间和table的end time
void update(int playerId, int tableId) {
    if (players[playerId].arriving_time <= tables[tableId].end) {
        players[playerId].starting_time = tables[tableId].end;
    } else {
        players[playerId].starting_time = players[playerId].arriving_time;
    }
    tables[tableId].end =
        players[playerId].starting_time + players[playerId].playing_time;
    tables[tableId].count++;
}

int findNextVip(int vipId) {
    vipId++;
    while (vipId < n && players[vipId].isVip == 0) vipId++;
    return vipId;
}

int main() {
    cin >> n;
    string arriving_time;
    int playing_time;
    int isVip;
    for (int i = 0; i < n; ++i) {
        cin >> arriving_time >> playing_time >> isVip;
        players[i].arriving_time = parse(arriving_time);
        players[i].playing_time =
            (playing_time > 120 ? 120 * 60 : playing_time * 60);
        players[i].isVip = isVip;
    }

    sort(players, players + n, cmp1);

    cin >> m >> k;
    for (int i = 0; i < k; ++i) {
        cin >> t;
        tables[t].isVip = 1;
    }

    int i = 0, vipId = -1;
    vipId = findNextVip(vipId);
    while (i < n) {
        int index = -1, minEndTime = inf;
        for (int j = 1; j <= m; ++j) {
            if (tables[j].end < minEndTime) {
                index = j;
                minEndTime = tables[j].end;
            }
        }
        if (tables[index].end >= 21 * 3600) break;
        if (players[i].isVip == 1 && i < vipId) {
            i++;
            continue;
        }
        // 如果是vip table
        if (tables[index].isVip == 1) {
            if (players[i].isVip == 1) {
                update(i, index);
                if (i = vipId) vipId = findNextVip(vipId);
                ++i;
            } else {
                // 考虑所排队列中是否有vip player
                if (vipId < n &&
                    players[vipId].arriving_time <= tables[index].end) {
                    update(vipId, index);
                    vipId = findNextVip(vipId);
                } else {
                    update(i, index);
                    ++i;
                }
            }
        } else {
            if (players[i].isVip == 0) {
                update(i, index);
                ++i;
            } else {
                int vipIndex = -1, minVipEndTime = inf;
                for (int j = 1; j <= m; ++j) {
                    if (tables[j].isVip == 1 && minVipEndTime > tables[j].end) {
                        vipIndex = j;
                        minVipEndTime = tables[j].end;
                    }
                }
                if (vipIndex != -1 &&
                    players[i].arriving_time >= tables[vipIndex].end) {
                    update(i, vipIndex);
                    if (vipId == i) vipId = findNextVip(vipId);
                    ++i;
                } else {
                    update(i, index);
                    if (vipId == i) vipId = findNextVip(vipId);
                    ++i;
                }
            }
        }
    }
    sort(players, players + n, cmp2);
    for (int i = 0; i < n && players[i].starting_time < 21 * 3600; ++i) {
        printf("%02d:%02d:%02d ", players[i].arriving_time / 3600,
               players[i].arriving_time % 3600 / 60,
               players[i].arriving_time % 60);
        printf("%02d:%02d:%02d ", players[i].starting_time / 3600,
               players[i].starting_time % 3600 / 60,
               players[i].starting_time % 60);
        printf("%.01d
",
               (players[i].starting_time - players[i].arriving_time + 59) / 60);
    }
    for (int i = 1; i <= m; ++i) {
        if (i != 1) cout << " ";
        cout << tables[i].count;
    }
    return 0;
}

有三组数据没有通过。

参考：

　　https://www.liuchuo.net/archives/2955