1014 Waiting in Line

最新推荐文章于 2025-09-17 15:19:08 发布

原创最新推荐文章于 2025-09-17 15:19:08 发布 · 250 阅读

0 ·

CC 4.0 BY-SA版权

PAT甲级专栏收录该内容

35 篇文章

订阅专栏

本文介绍了一个银行服务客户排队模拟的问题，通过使用vector变长数组来模拟每个窗口的队列，客户选择等待在最短的队列中，直到他们的业务完成。文章详细解释了算法的实现细节，包括如何处理客户在17:00前未被服务的情况。

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 Mcustomers. 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.
Customeri will take Ti 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 custmers 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, customer1 is served at window1 while customer2is served at window2. Customer3 will wait in front of window1 and customer4 will wait in front of window2. Customer5 will wait behind the yellow line.

At 08:01, customer1 is done and customer5 enters the line in front of window1 since that line seems shorter now. Customer2 will leave at 08:02, customer4 at 08:06, customer3 at 08:07, and finally customer5 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

题型分类：快乐模拟

题目大意：银行服务客户，客户在N个窗口处进行排队，每个窗口可以排M人的队伍。

解题思路：用一个vector变长数组来模拟买个窗口的队列，进入队列就调用push_back，离开队列的时候，使用erase删去队列最前面的那位客户。这题有两个易错点：

1.客户是排在最先空出位置的窗口处，不是整条队列全部服务完时间最短的窗口处。

2.客户在17:00之前不被服务的话，就输出Sorry。注意，这里是17:00之前没有开始服务，并不是服务时间超出17:00就输出Sorry。仔细想一下题目设置也挺合理的，总不能服务到一半，超过了下班点就马上闪人吧。

#include <cstdio>
#include <vector>

using namespace std;

const int maxWin = 25; //最大服务窗口数量
const int maxCus = 1005; //最大客户数量
const int stTime = 8 * 60; //8点
const int edTime = 17 * 60; //17点
const int INF = 0x3f3f3f3f;

typedef struct {
	bool isServed;
	int serveTime; //客户的服务时间
	int finishTime; //客户的服务结束时间，用于最后的查询
} customer;

vector<int> win[maxWin]; //用来存储对应序号窗口的服务客户完成时间，第一个位置用来存储队列的总时间 
customer cus[maxCus];

int main(int argc, char** argv) {
	int N, M, K, Q;
	scanf("%d %d %d %d", &N, &M, &K, &Q);
	for(int idCus = 0; idCus < K; idCus++) {
		scanf("%d", &cus[idCus].serveTime);
	}
	for(int idWin = 0; idWin < N; idWin++) { //win数组的第一个用来存储这个窗口的服务结束时间，初始为8点
		win[idWin].push_back(stTime);
	}
	for(int idCus = 0; idCus < K; idCus++) { //idCus表示服务的客户号码
		if(idCus < N * M) { //先把队伍排满
			int idWin = idCus % N;
			if(win[idWin][0] < edTime) cus[idCus].isServed = true;
			else cus[idCus].isServed = false;
			win[idWin][0] = win[idWin][0] + cus[idCus].serveTime; //更新服务完整个队列的时间
			cus[idCus].finishTime = win[idWin][0];
			win[idWin].push_back(cus[idCus].finishTime);
		} else {
			int idWin = -1, minTime = INF; //minTine表示最快服务完当前窗口的时间,这样队伍就会空出来 
			for(int i = 0; i < N; i++) {
				if(win[i][1] < minTime) { //win[i][1]存储的是窗口最前面的客户完成服务的时间 
					idWin = i;
					minTime = win[i][1];
				}
			}
			if(win[idWin][0] < edTime) cus[idCus].isServed = true;
			else cus[idCus].isServed = false;
			win[idWin][0] = win[idWin][0] + cus[idCus].serveTime;
			cus[idCus].finishTime = win[idWin][0];
			win[idWin].push_back(cus[idCus].finishTime); //插入新的客户到队尾
			win[idWin].erase(win[idWin].begin() + 1); //删除最前面那个服务的客户 
		}
	}
	for(int i = 0; i < Q; i++) {
		int query;
		scanf("%d", &query);
		query--;
		if(cus[query].isServed == true) {
			printf("%02d:%02d\n", cus[query].finishTime / 60, cus[query].finishTime % 60);
		} else {
			printf("Sorry\n");
		}
	}
	return 0;
}