PAT 1017. Queueing at Bank (25)

1017. Queueing at Bank (25)

时间限制

400 ms

内存限制

65536 kB

代码长度限制

16000 B

判题程序

Standard

作者

CHEN, Yue

Suppose a bank has K windows open for service. There is a yellow line in front of the windows which devides the waiting area into two parts. All the customers have to wait in line behind the yellow line, until it is his/her turn to be served and there is a window available. It is assumed that no window can be occupied by a single customer for more than 1 hour.

Now given the arriving time T and the processing time P of each customer, you are supposed to tell the average waiting time of all the customers.

Input Specification:

Each input file contains one test case. For each case, the first line contains 2 numbers: N (<=10000) - the total number of customers, and K (<=100) - the number of windows. Then N lines follow, each contains 2 times: HH:MM:SS - the arriving time, and P - the processing time in minutes of a customer. Here HH is in the range [00, 23], MM and SS are both in [00, 59]. It is assumed that no two customers arrives at the same time.

Notice that the bank opens from 08:00 to 17:00. Anyone arrives early will have to wait in line till 08:00, and anyone comes too late (at or after 17:00:01) will not be served nor counted into the average.

Output Specification:

For each test case, print in one line the average waiting time of all the customers, in minutes and accurate up to 1 decimal place.

Sample Input:

7 3
07:55:00 16
17:00:01 2
07:59:59 15
08:01:00 60
08:00:00 30
08:00:02 2
08:03:00 10

Sample Output:

8.2

题目解析：
本题要做的模拟排队，题目给出多个客户到达时间和业务所需时间，统计客户平均等待时间。
要做的就是：1）根据客户到达时间按序处理；2）客户到达时如果需要等待则累计等待时间；3）计算平均累计等待时间。
考察重点：
模拟算法
注意点：
17点以后的客户不接待也不加入计算等待时间，银行接待时间为08:00到17:00。
时间可能很大，计算最短时间时初始化最好设大一点，不然最后一个测试点会出错。
以下java代码运行最后一个测试点会超时。
本份java代码思路：
1、对顾客到达时间排序。
2、使用Windows数组保存窗口事务处理结束时间。
3、顾客总是选择事务处理结束时间最短的窗口进行服务。
4、如果客户到达时没有窗口空闲，即所有窗口的事务处理结束时间均大于客户到达时间，则进行等待时间累积，否则选择序号最小的一个进行服务。

import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

public class Main {
	private static final int START = 8 * 60 * 60;
	private static final int STOP = 17 * 60 * 60;

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int N = scanner.nextInt();
		int K = scanner.nextInt();
		int waitTime = 0;
		Map<Integer, Integer> map = new TreeMap<Integer, Integer>();
		int[] windows = new int[K];
		int arrive_t = 0;
		int proc_t = 0;
		for (int i = 0; i < N; i++) {
			arrive_t = getTime(scanner.next());
			proc_t = scanner.nextInt() * 60;
			if (arrive_t < STOP)
				map.put(arrive_t, proc_t);
		}
		scanner.close();
		for (int i = 0; i < K; i++) {
			windows[i] = START;
		}
		for (int key : map.keySet()) {
			waitTime += wait(key, map.get(key), windows, K);
		}
		System.out.printf("%.1f", waitTime / 60.0 / map.size());
	}

	static int wait(int arrie, int proc, int[] windows, int K) {
		int time = 0;
		int min = Integer.MAX_VALUE;
		int min_i = 0;
		for (int i = 0; i < K; i++) {
			if (arrie > windows[i]) {
				windows[i] = arrie + proc;
				return 0;
			} else {
				if (windows[i] < min) {
					min = windows[i];
					min_i = i;
				}
			}
		}
		time = windows[min_i] - arrie;
		windows[min_i] = windows[min_i] + proc;
		return time;
	}

	static int getTime(String time) {
		final String[] split = time.split(":");
		return Integer.valueOf(split[0]).intValue() * 60 * 60 + Integer.valueOf(split[1]).intValue() * 60
				+ Integer.valueOf(split[2]).intValue();
	}
}

附上同样思路的c++代码

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int START = 8 * 60 * 60;
const int STOP = 17 * 60 * 60;
int wait(int arrie, int proc, int* windows, int K) {
	int time = 0;
	int min = 0x7fffffff;
	int min_i = 0;
	for (int i = 0; i < K; i++) {
		if (arrie > windows[i]) {
			windows[i] = arrie + proc;
			return 0;
		} else {
			if (windows[i] < min) {
				min = windows[i];
				min_i = i;
			}
		}
	}
	time = windows[min_i] - arrie;
	windows[min_i] = windows[min_i] + proc;
	return time;
}

int getTime(char* time) {
	return ((time[0] - '0') * 10 + time[1] - '0') * 60 * 60
			+ ((time[3] - '0') * 10 + time[4] - '0') * 60
			+ ((time[6] - '0') * 10 + time[7] - '0');
}

struct Customer {
	int arrive;
	int proc;
} cus[10000];
bool cmp(const Customer &c1, const Customer &c2) {
	return c1.arrive < c2.arrive;
}
int main() {
	int N;
	int K;
	cin >> N >> K;
	int waitTime = 0;
	int num = 0;
	int windows[100];
	char arrive_s[10];
	int arrive_t;
	int proc_t = 0;
	for (int i = 0; i < N; i++) {
		cin >> arrive_s;
		arrive_t = getTime(arrive_s);
		cin >> proc_t;
		proc_t *= 60;
		if (arrive_t <= STOP) {
			cus[num].arrive = arrive_t;
			cus[num].proc = proc_t;
			num++;
		}
	}
	for (int i = 0; i < K; i++) {
		windows[i] = START;
	}
	sort(cus, cus + num, cmp);
	for (int i = 0; i < num; i++) {
		waitTime += wait(cus[i].arrive, cus[i].proc, windows, K);
	}
	printf("%.1f", waitTime / 60.0 / num);
	return 0;
}