【PAT】【模拟】1014 Waiting in Line

1014 Waiting in Line (30 分)

Suppose a bank has N windows open for service. There is a yellow line in front of the windows which devides the waiting area into two parts. The rules for the customers to wait in line are:

• The space inside the yellow line in front of each window is enough to contain a line with M customers. Hence when all the N lines are full, all the customers after (and including) the (NM+1)st one will have to wait in a line behind the yellow line.
• Each customer will choose the shortest line to wait in when crossing the yellow line. If there are two or more lines with the same length, the customer will always choose the window with the smallest number.
• Customer​i​​ will take T​i​​ minutes to have his/her transaction processed.
• The first N customers are assumed to be served at 8:00am.

Now given the processing time of each customer, you are supposed to tell the exact time at which a customer has his/her business done.

For example, suppose that a bank has 2 windows and each window may have 2 customers waiting inside the yellow line. There are 5 customers waiting with transactions taking 1, 2, 6, 4 and 3 minutes, respectively. At 08:00 in the morning, customer​1​​ is served at window​1​​ while customer​2​​ is served at window​2​​. Customer​3​​ will wait in front of window​1​​ and customer​4​​ will wait in front of window​2​​. Customer​5​​ will wait behind the yellow line.

At 08:01, customer​1​​ is done and customer​5​​ enters the line in front of window​1​​ since that line seems shorter now. Customer​2​​ will leave at 08:02, customer​4​​ at 08:06, customer​3​​ at 08:07, and finally customer​5​​ at 08:10.

Input Specification:

Each input file contains one test case. Each case starts with a line containing 4 positive integers: N (≤20, number of windows), M (≤10, the maximum capacity of each line inside the yellow line), K (≤1000, number of customers), and Q (≤1000, number of customer queries).

The next line contains K positive integers, which are the processing time of the K customers.

The last line contains Q positive integers, which represent the customers who are asking about the time they can have their transactions done. The customers are numbered from 1 to K.

Output Specification:

For each of the Q customers, print in one line the time at which his/her transaction is finished, in the format HH:MM where HH is in [08, 17] and MM is in [00, 59]. Note that since the bank is closed everyday after 17:00, for those customers who cannot be served before 17:00, you must output Sorry instead.

Sample Input:

2 2 7 5
1 2 6 4 3 534 2
3 4 5 6 7

Sample Output:

08:07
08:06
08:10
17:00
Sorry

 

 题目大意：

银行排队，先排满黄线内区域，再每有一个人办完业务，则加入该队列，同时则窗口编号小的优先，查询输出指定的人办完业务的时间；

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
using namespace std;

//用优先队列写了个很混乱的写法
//思路还是不够有条理，写的一片混乱
//有空再进行优化，写另一版本

inline void read(int &x)
{
    register int f = 1; x = 0;
    register char c = getchar();
    while(c > '9' || c < '0')
    {
        if(c == '-') f = -1;
        c = getchar();
    }
    while(c >= '0' && c <= '9')
    {
        x = (x << 3) + (x << 1) + (c ^ 48);
        c = getchar();
    }
    x *= f;
}

struct node
{
    int id, tm, wnum;
    bool operator<(const node &rhs) const;
};
//重载运算符
bool node::operator<(const node &rhs) const
{
//    办完业务时间早的排前面
    if(this->tm != rhs.tm)
    {
        return this->tm > rhs.tm;
    }
//    相同则窗口号小的优先
    else return this->wnum > rhs.wnum;
}

const int maxn = 1e3 + 5;
priority_queue<node> w;
int n, m, k, q;
//每个人离开的时间
int ans[maxn];
//每个窗口的办完最后一个业务总的时间
int last[25];

//求出之后排队的人的出队时间，即办完业务的时间
inline void solve(int k, int dfn = n * m)
{
    while(k--)
    {
        node t = w.top();
        w.pop();
        ans[t.id] = t.tm;
        int in; read(in);
//        已经关门，无法再入队
        if(last[t.wnum] < 540)
        w.push((node){++dfn, last[t.wnum] += in, t.wnum});
        else ans[++dfn] = -1;
    }
//    给已经入队的人办完业务出队，记录时间
    while(!w.empty())
    {
        ans[w.top().id] = w.top().tm;
        w.pop();
    }
}

int main()
{
    read(n); read(m); read(k); read(q);
//    填满黄线内位置
    for(int j = 0; j < m; j++)
    {
        for(int t, i = 1; i <= n && i + j * n<= k; i++)
        {
             read(t);
             if(j == 0)
             {
                 w.push((node){i + j * n, t, i});
                 last[i] = ans[i] = t;
             }
             else
             {
//                 已经关门，无法再入队
                 if(last[i] < 540)
                 {
                     last[i] = ans[n * j + i] = ans[n * j + i - n] + t;
                     w.push((node){i + j * n, last[i], i});
                 }
                 else ans[n * j + i] = -1;
             }
        }
    }
//    若能填满
    if(k > n * m && n && m)
    solve(k - n * m);

//    输出每次查询的结果
    for(int t, i = 1; i <= q; i++)
    {
        read(t);
        if(ans[t] != -1)
        {
            int f = ans[t] % 60;
            int temp = ans[t] / 60;
            int h = (temp + 8) % 24;
            printf("%02d:%02d\n", h, f);
        }
        else printf("Sorry\n");
    }
    return 0;
}