题目链接
    题目不难读懂，并且不涉及什么算法，但是逻辑上非常繁琐，算法笔记上有非常详细的题意解释，这里就不赘述了。

    这里主要是写我用的一种模拟时间滴答的方法，逻辑上可能要简单一些。
    主要就是将题目中的时间 08:00:00 - 21:00:00 以每秒一个间隔，总共 13*60*60=46800 个时钟滴答，在每一个始终滴答到来的时候，依次处理玩家到达事件、桌子使用计时减1事件、空桌子安排玩家使用事件。
    这样思考总体上逻辑简洁一些。

    具体的看代码 ：

    1. #include<bits/stdc++.h>
    2. using namespace std;
    3. #define MAXPEOPLE 10005
    4. #define MAXTABLE 105
    5. #define TIME2SECOND(h,m,s) ((((h) - 8) * 3600) + ((m) * 60) + (s))
    6. #define MINUTE2SECOND(m) ((m) * 60)
    7. #define MAXTIMESTAMP 46800
    10. int second2minute(int s)
    11. {
    12.     //秒数转分钟，并且舍入
    13.     int m = s / 60;
    14.     if ((s % 60) >= 30)
    15.         m++;
    16.     return m;
    17. }
    19. void printTime(int second)
    20. {
    21.     //根据秒数打印时间
    22.     int h, m, s;
    23.     h = second / 3600 + 8;
    24.     second = second % 3600;
    25.     m = second / 60;
    26.     second = second % 60;
    27.     s = second;
    28.     printf("%02d:%02d:%02d ", h, m, s);
    29. }
    31. struct People
    32. {
    33.     int arrTime = 0;    //到达时间
    34.     int needTime = 0;    //需要的时间
    35.     int serverTime = -1;    //服务开始时间
    36.     bool VIP = false;        //是否是VIP
    37.     bool servered = false;    //是否已被服务
    38. };
    40. int n, tableNum, viptableNum, minemptytable;    //记录数、桌子总数，vip桌子总数，索引号最小的空桌子的索引
    41. int timeStamp;    //时间戳,8:00:00为0,21:00:00为46800
    42. int serverIndex, arriveIndex;    //当前未服务玩家的索引、当前可服务玩家索引  [serverIndex,arriveIndex)为当前时间
    43.                                 //可服务但尚未服务的玩家
    44. queue<int> VIPwaitIndex;        //在等待中的vip玩家
    45. People playpairs[MAXPEOPLE];    //玩家记录
    46. int tables[MAXTABLE] = { 0 };    //当前桌子还要用多久，0代表空桌子
    48. bool isVIP[MAXTABLE] = { false };    //记录桌子是不是VIP桌
    49. int serverNum[MAXTABLE] = { 0 };    //每个桌子服务过的人数
    50. vector<int> VIPtable;        //记录vip桌子的索引
    52. void dealServerIndex();
    53. void handelTableUse()
    54. {
    55.     //在每一个时钟滴答到来时，将正在使用的桌子的使用时间减少1，如果减少后为0，则该桌子为空，考虑更新minemptytable
    56.     int i;
    57.     for (i = 0; i < tableNum; i++) {
    58.         if (tables[i] > 0)
    59.             tables[i]--;
    60.         if (tables[i] == 0)
    61.             if (i < minemptytable)    //考虑更新minemptytable
    62.                 minemptytable = i;
    63.     }
    64. }
    66. void serverPeople(int peopleIndex, int tableIndex)
    67. {
    68.     //服务playpairs中索引号为peopleIndex的玩家，使用的桌子为tableIndex
    69.     playpairs[peopleIndex].servered = true;    //标记已服务
    70.     playpairs[peopleIndex].serverTime = timeStamp;    //记录服务时间
    71.     tables[tableIndex] = playpairs[peopleIndex].needTime;    //开始桌子时间的倒计时
    72.     serverNum[tableIndex]++;    //记录该桌子的服务人数
    73.     while (minemptytable < tableNum && tables[minemptytable]>0) {
    74.         //更新minemptytable，这里一定要用while，因为空桌子不是连续的
    75.         minemptytable++;
    76.     }
    77.     dealServerIndex();
    78. }
    80. void dealServerIndex()
    81. {
    82.     //更新待服务玩家索引serverIndex，这里一定要用while，因为可能存在有的玩家因为VIP插队的原因已经被服务了
    83.     while (playpairs[serverIndex].servered) {
    84.         serverIndex++;
    85.     }
    86. }
    88. void dealVIPtable()
    89. {
    90.     //处理空的VIP专属桌子
    91.     for (int t : VIPtable) {
    92.         if (tables[t] == 0 && !VIPwaitIndex.empty()) {
    93.             //桌子为空且有VIP玩家在等待，则服务这个玩家
    94.             int p = VIPwaitIndex.front();
    95.             VIPwaitIndex.pop();
    96.             serverPeople(p, t);
    97.         }
    98.     }
    99. }
    101. void handelEmptyTable()
    102. {
    103.     //在每一个时钟滴答，把桌子的使用倒计时-1后，处理所有的空桌子
    104.     dealVIPtable();    //首先处理VIP桌子，因为如果等待队列中的第一人是VIP，
    105.                     //且同时存在VIP桌子和普通桌子时，优先选择VIP桌子
    107.     //按序处理所有空桌子
    108.     while (minemptytable < tableNum && serverIndex < arriveIndex) {
    109.         if (playpairs[serverIndex].VIP) {
    110.             //如果排在第一的是一个VIP玩家，则他一定没有VIP桌子可用了，所以他用了一个普通桌子，
    111.             //因此不会在dealVIPtable()中出对，故要移出VIP等待队列
    112.             VIPwaitIndex.pop();
    113.         }
    114.         serverPeople(serverIndex, minemptytable);
    115.     }
    116. }
    118. void handelPeopleArrive()
    119. {
    120.     //在每一个时钟滴答，如果到了下一个玩家到来的时间，就将arriveIndex++，代表到达了
    121.     //一个新的玩家，并考虑他是不是VIP，是则加入VIP等待队列
    122.     if (playpairs[arriveIndex].arrTime == timeStamp) {
    123.         if (playpairs[arriveIndex].VIP) {
    124.             VIPwaitIndex.push(arriveIndex);
    125.         }
    126.         arriveIndex++;
    127.     }
    128. }
    130. int main() {
    131.     int h, m, s, i, need, tag;
    132.     scanf("%d", &n);
    133.     for (i = 0; i < n; i++) {
    134.         //玩家信息输入
    135.         scanf("%d:%d:%d %d %d", &h, &m, &s, &need, &tag);
    136.         if (need > 120) {
    137.             need = 120;
    138.         }
    139.         playpairs[i].arrTime = TIME2SECOND(h, m, s);
    140.         playpairs[i].needTime = MINUTE2SECOND(need);
    141.         if (tag == 1)
    142.             playpairs[i].VIP = true;
    143.     }
    144.     scanf("%d %d", &tableNum,&viptableNum);
    145.     for (i = 0; i < viptableNum; i++) {
    146.         //桌子信息输入
    147.         int v;
    148.         scanf("%d", &v);
    149.         VIPtable.push_back(--v);    //将桌子索引转为0开始
    150.         isVIP[v] = true;
    151.     }
    153.     //按照玩家到达时间升序排列
    154.     sort(playpairs, playpairs + n, [](People& a, People& b) {return a.arrTime < b.arrTime; });
    156.     serverIndex = 0;
    157.     minemptytable = 0;
    158.     arriveIndex = 0;
    159.     for (timeStamp = 0; timeStamp < MAXTIMESTAMP; timeStamp++) {
    160.         //每一个时间戳，首先处理玩家到达事件，再处理桌子使用计时减1事件，最后处理
    161.         //空桌子使用事件，三者的顺序不能颠倒
    162.         handelPeopleArrive();
    163.         handelTableUse();
    164.         handelEmptyTable();
    165.         if (serverIndex == arriveIndex == n)    
    166.             //所有玩家都已经服务了
    167.             break;
    168.     }
    170.     for (i = serverIndex; i < arriveIndex; i++) {
    171.         //在[serverIndex,arriveIndex)中，可能存在因为VIP插队而已被服务的玩家，故要
    172.         //把该玩家提前，这样最后在[0,serverIndex)中的就是全部服务过的玩家
    173.         if (playpairs[i].servered) {
    174.             playpairs[serverIndex++] = playpairs[i];
    175.         }
    176.     }
    178.     //根据服务时间升序排列
    179.     sort(playpairs, playpairs + serverIndex, [](People& a, People& b) {return a.serverTime < b.serverTime; });
    181.     //答案输出
    182.     for (i = 0; i < serverIndex; i++) {
    183.         printTime(playpairs[i].arrTime);
    184.         printTime(playpairs[i].serverTime);
    185.         printf("%d\n", second2minute(playpairs[i].serverTime - playpairs[i].arrTime));
    186.     }
    187.     printf("%d", serverNum[0]);
    188.     for (i = 1; i < tableNum; i++) {
    189.         printf(" %d", serverNum[i]);
    190.     }
    192.     return 0;
    193. }
    196. /*
    197. //input
    198. 2
    199. 08:00:00 10 1
    200. 08:05:00 10 1
    201. 3 2
    202. 2 3
    204. //output
    205. 08:00:00 08:00:00 0
    206. 08:05:00 08:05:00 0
    207. 0 1 1
    208. */
    211. /*
    212. //input
    213. 2
    214. 20:00:00 60 0
    215. 20:30:00 10 1
    216. 1 1
    217. 1
    219. //output
    220. 20:00:00 20:00:00 0
    221. 1
    222. */

    最下面是算法笔记上给出的几组测试数据。
    PAT1026 Table Tennis (30分)时间戳法 - 图1
    这种方法虽然外层循环有46800次，但是内层大部分时间只是一个简单的判断，没有实际操作，所以耗时并不高。