PAT 1014 Waiting in Line（模拟+队列操作）

题目

https://www.patest.cn/contests/pat-a-practise/1014

银行前台处理客户的过程如下，有n个窗口，每个窗口前的队伍可以排m个人，其余人在黄线外等待；每当有人处理完毕时，黄线外的人找最短的、序号最小队伍插入；求每个人的结束时间。

解题思路

本题是明显的队列的模拟题，遗憾的是改了好久代码只过了四组，最后一组依然是段错误，虽然还不知道什么原因:(，看了一下网上大神的代码，非常简练明了，五体投地。（参考：http://blog.csdn.net/acm_ted/article/details/20473255）

先把n*m个客户加入对应的n的窗口队列中，如果还有客户，枚举判断出n个窗口中最早处理完的队列，然后将用户加入此队列。
最后将时间和时限进行比较，输出。

和自己实现的相比，有两个最大的不同：

• 为每个客户构造一个结构体，记录耗时，开始时间和结束时间
• 利用了每位顾客插入队伍时，就决定了什么时候轮到他，什么时候离开，因此没必要完全模拟，处理直到所有队列都为空，不然会比较杂乱不够清晰

需要注意的是，如果一个顾客在17:00前(<=16:59)能轮到即可，不要求在17:00前处理完毕。

AC代码

参考别人博客修改后的代码

#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxcnt = 1005;
const int maxn = 25;

typedef struct node
{
    int wasteTime; //每位顾客耗时
    int sTime,eTime; //开始和结束时间
}customer;

typedef struct windows
{
    int eTime; //本窗口处理完的时间
    queue<int> q;
}window;

///利用了每位顾客插入队伍时，就决定了什么时候轮到他，什么时候离开，没必要完全模拟直到队列都空了
int main()
{
    customer cust[maxcnt];
    window win[maxn];
    int n,m,cnt,q;
    int num, minTime, idx, pos;
    cin >> n >> m >> cnt >> q;
    for (int i = 1; i <= cnt; ++i)
        cin >> cust[i].wasteTime;
    num = 1;
    int first = min(n*m, cnt);
    for (int i = 0; num <= first; ++num, i=(i+1)%n) //插入第一批顾客
    {
        cust[num].sTime = win[i].eTime;
        cust[num].eTime = cust[num].sTime + cust[num].wasteTime; //顾客的时间确定，用于输出他自己
        win[i].eTime += cust[num].wasteTime; //窗口的结束时间确定，用于下一个客户的初始化
        win[i].q.push(num);
    }
    for (; num <= cnt; ++num) //处理剩余的顾客
    {
        minTime = INF;
        for (int i = 0; i<n; ++i) //找到队列中能最先完成的
        {
            idx = win[i].q.front();
            if (cust[idx].eTime < minTime)
            {
                minTime = cust[idx].eTime;
                pos = i;
            }
        }
        //插入新顾客的时间确定化
        cust[num].sTime = win[pos].eTime;
        cust[num].eTime = cust[num].sTime + cust[num].wasteTime;
        win[pos].eTime += cust[num].wasteTime;
        win[pos].q.pop();
        win[pos].q.push(num);
    }//插入完毕

    int hour, minute, query;
    while(q--)
    {
        cin >> query;
        if (cust[query].sTime >= 540)
            cout << "Sorry" << endl;
        else
        {
            hour = (cust[query].eTime + 8*60)/60;
            minute = (cust[query].eTime + 8*60)%60;
            if (hour >= 10)
                printf("%d:",hour);
            else
                printf("0%d:",hour);
            if (minute>= 10)
                printf("%d\n",minute);
            else
                printf("0%d\n",minute);
        }
    }
    return 0;
}

自己复杂的代码，最后一个测试点段错误

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxcnt = 1005;
const int maxn = 25;
int n, m, cnt;
int cost[maxcnt]; //time needed for each customer

typedef struct node
{
    queue<int> q;
    int spent;
}LINE;

LINE win[maxn];
int myTurn[maxn];

void init()
{
    memset(myTurn, 0, sizeof(myTurn));
    for (int i = 0; i < n; ++i)
        win[i].spent = 0;
    int first = min(n*m, cnt);
    for (int i = 1; i <= first; ++i)
        (win[(i-1) % n].q).push(i);
}

void calc_time()
{
    int minn, smallest;
    for (int out = n*m+1; out <= cnt; ++out) //处理还在黄线外的人
    {
        minn = 0, smallest = INF;
        for (int i = 0; i < n; ++i) //选择一个最早能空出来的队列编号minn
        {
            //发现一个空的队列
            if (win[i].q.empty())
            {
                minn = i;
                break;
            }
            //更新smallest和minn
            int predict = win[i].spent + cost[(win[i].q).front()]; //本队列腾出空位的时间
            if (predict < smallest)
            {
                smallest = predict;
                minn = i;
            }
        }
        if (win[minn].q.empty() == false) //所选队列不空
        {
            int who_pop = (win[minn].q).front();
            win[minn].q.pop();
            myTurn[who_pop] = win[minn].spent; //who_pop的开始时间为之前队列的耗时
            win[minn].spent = smallest;
        }
        win[minn].q.push(out);
    }
    //黄线外已经处理完
    for (int i = 0; i<n; ++i)
    {
        while(win[i].q.empty() == false)
        {
            myTurn[win[i].q.front()] = win[i].spent;
            win[i].spent += cost[win[i].q.front()];
            win[i].q.pop();
        }
    }
}

int main()
{
    int q;
    cin >> n >> m >> cnt >> q;
    for (int i = 1; i <= cnt; ++i)
        cin >> cost[i];
    init();
    calc_time();
    int query, start, hour, minu;
    for (int i = 0; i < q; ++i)
    {
        cin >> query;
        start = myTurn[query];
        if (start >= 540)
            cout << "Sorry" << endl;
        else
        {
            hour = 8, minu = start + cost[query];
            hour += (minu/60);
            minu %= 60;
            if (hour < 10) printf("0%d:", hour);
            else printf("%d:",hour);
            if (minu < 10) printf("0%d", minu);
            else printf("%d",minu);
            cout << endl;
        }
    }
    return 0;
}