题目

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$ ( $\le 20$ , number of windows), $M$ ( $\le 10$ , the maximum capacity of each line inside the yellow line), $K$ ( $\le 1000$ , number of customers), and $Q$ ( $\le 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:

1
2
3

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

Sample Output:

1
2
3
4
5

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

鸣谢用户 不到76kg不改名 和 徐向荣 补充数据！

思路

题意解读:

银行有N个窗口, 每个窗口允许排M个顾客. 一大早8点所有顾客商量好蜂拥而入, 那么情况有两种: 1, 顾客全部能排在队伍里; 2, 顾客人数太多, 有人排在外面, 要等前面的顾客完成离开, 再进入列列.

注意点:

  • 时间截止的标准是: 进入列列不晚于下午5点即可. 也就是说以进入列列时间为标准, 中间用多长时间都没问题. 这个点包括我很多人肯定第一感觉是理解错的.

代码结构

解读题目时提到可以存在两种情况, 我将这两种情况合并了一下:

  • 顾客一共有K个, 如果K<=M*N, 那么我用下面这图表示人次的流动情况(E表示入列, D表示 出列, -表示此时无此操作):

    1
2
3

    时间顺序或者操作顺序-->
出列: -----------------DDD...(K*D)...DDD
入列: EEE...(K*E)...EEE-----------------

    即表示一起进行K次入列, 然后一起进行K次出列, 就完成了.

  • 如果K>M*N, 那么其中有一段时间会交替有人出列/入列, 表示起来就是:

    1
2
3

    时间顺序或者操作顺序-->
出列: ----(M*N)-----DDDDDD...(K*D)...DDD
入列: EEE...(K*E)...EEEEEE----(M*N)-----

    这表示前MN次只有入列, 中间有顾客出列, 有顾客入列, 最后MN次只有出列.

总结这两种情况, 都是前K次是入列, 后K次是出列, 只需再计算出总的操作次数(出入记为 一次)即可, 其实就是max(2*K, M*N+K).

这样代码结构就是

1
2
3
4
5

循环max(2*K, M*N+K)次:
    如果是后K次:
        出列
    如果是前K次:
        入列

计时方法

数据结构:

  • 用一个数组(长度至少为K+1, 后面解释)先记录每个顾客的所需时间. 后面操作将这个时间 更新为顾客入列时间.

    时间为距离早8点的分钟数.

    如实按顾客编号(即从1开始)记录, 角标为0的元素保持为0.

  • 用N个队列模拟相关过程, 记录内容为顾客标号, 但是队列长度至少为M+1(后面解释)

操作主要在入列时(因为入列时间很重要)

入列时:

  • 找到长度最短的队列
  • 找到前面一个人的(包括标号0)对应时间
  • 将将要入列的人的时间加上上述时间, 即得到了此人的入列时间

出列时:

  • 只需找到所有队列队首中时间最早的对其出列即可

代码

Github最新代码，欢迎交流

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

#include <stdio.h>

#define LATE_FLAG -1
#define FORWARD(I) ((I) = ((I) == 10) ? 0 : ((I) + 1))
#define TIME_FRONT(I) time[queue[I][front[I]]]
#define TIME_REAR_PREVIOUS(I) time[queue[I][(rear[I] == 0) ? 10 : (rear[I] - 1)]]

int main()
{
	int N, M, K, Q, query;
	int time[1000] = {0}, queue[20][11] = {{0}};
	int front[20] = {0}, rear[20] = {0}, length[20] = {0};

	scanf("%d %d %d %d", &N, &M, &K, &Q);
	for (int i = 1; i <= K; i++)
		scanf("%d", time + i);

	/* Total number of operations */
	int count = (K < M * N) ? (2 * K) : (K + M * N);
	/* Doing dequeues and enqueues for every customer */
	for (int i = 1; i <= count; i++) {
		if (i > count - K) { /* Dequeue in the last K operations */
			/* Find the next customer */
			int time_span = 9999, next = -1;
			for (int j = 0; j < N; j++)
				if (length[j]) {
						if (TIME_FRONT(j) < time_span)
						next = j, time_span = TIME_FRONT(j);
						else if (next == -1 && TIME_FRONT(j) == LATE_FLAG)
						next = j;
				}
			/* Dequeue */
			FORWARD(front[next]);
			length[next]--;
		}
		if (i <= K) { /* Enqueue in the first K operations */
			/* Find shortest queue */
			int shortest = 0;
			for (int j = 0; j < N; j++)
				if (length[shortest] > length[j])
						shortest = j;
			/* Set flag or add time */
			int previous_time = TIME_REAR_PREVIOUS(shortest);
			if (previous_time >= 9 * 60 || previous_time == LATE_FLAG)
				time[i] = LATE_FLAG;
			else
				time[i] += previous_time;
			/* Enqueue */
			queue[shortest][rear[shortest]] = i;
			FORWARD(rear[shortest]);
			length[shortest]++;
		}
	}

	/* Read queries and print answers */
	for (int i = 0; i < Q; i++) {
		scanf("%d", &query);
		if (time[query] != LATE_FLAG)
			printf("%02d:%02d\n", 8 + time[query] / 60, time[query] % 60);
		else
			printf("Sorry\n");
	}

	return 0;
}