SJTU打印机队列

打印机队列

计算机科学学会中唯一的打印机正在经历非常繁重的工作。有时打印机队列中有一百个作业，您可能需要等待几个小时才能获得一页输出。

因为某些作业比其他作业更重要，所以Hacker已经为打印作业队列发明并实现了一个简单的优先级系统。现在，为每个作业分配1到9之间的优先级（其中9为最高优先级，1为最低），打印机的操作如下

将队列中的第一个作业J从队列中取出。

如果队列中的某些作业具有比作业J更高的优先级，则将J移动到队列的末尾而不打印它。

否则，打印作业J（并且不要将其放回队列中）。

这样，Hacker可以将自己特别喜欢的红烧肉食谱很快地打印出来。当然，其他人正在打印的那些令人讨厌的学期论文可能不得不等待相当长的时间才能得到打印，但这就是生活啊。

现在的问题在于，确定何时实际完成打印作业已经变得非常棘手。请您编写一个程序来解决这个问题。为了简化问题，我们假设打印作业始终只花费一分钟，并且从队列中添加和删除作业是即时的。

【输入形式】

带有正整数的一行：测试用例的数量（最多100个）。然后对于每个测试用例：

一行包含两个整数n和m，其中n是队列中的作业数（1≤n≤100），m是作业的位置（0≤m≤n -1）。队列中的第一个位置是数字0，第二个是数字1，依此类推。

一行，其中n个整数在1到9的范围内，给出了队列中作业的优先级。第一个整数赋予第一个作业的优先级，第二个整数赋予第二个作业的优先级，依此类推。

【输出形式】

对于每个测试用例，请用单个整数打印一行；假设没有其他打印作业到达，直到完成打印作业为止的分钟数。

【样例输入】

3
1 0
5
4 2
1 2 3 4
6 0
1 1 9 1 1 1

【样例输出】

1
2
5
【提示】

循环队列

#include <iostream>
using namespace std;

template <class elemType>
class seqQueue
{
private:
	elemType* elem;
	int maxSize;
	int front, rear;
	void doubleSpace();

public:
	seqQueue(int size);
	~seqQueue();
	bool isEmpty()const;
	void enQueue(const elemType& x);
	elemType deQueue();
	elemType getHead()const;
};

template <class elemType>
seqQueue<elemType>::seqQueue(int size)
{
	elem = new elemType[size];
	maxSize = size;
	front = rear = 0;
}

template <class elemType>
seqQueue<elemType>::~seqQueue()
{
	delete[] elem;
}

template <class elemType>
bool seqQueue<elemType>::isEmpty()const
{
	return front == rear;
}


template <class elemType>
void seqQueue<elemType>::enQueue(const elemType& x)
{
	if ((rear + 1) % maxSize == front) doubleSpace();
	rear = (rear + 1) % maxSize;
	elem[rear] = x;
}

template <class elemType>
void seqQueue<elemType>::doubleSpace()
{
	elemType* tmp = elem;
	elem = new elemType[2 * maxSize];
	for (int i = 1; i <= maxSize; ++i) {
		elem[i] = tmp[(front + i) % maxSize];
	}
	front = 0; rear = maxSize - 1;
	maxSize *= 2;
	delete tmp;
}

template <class elemType>
elemType seqQueue<elemType>::deQueue()
{
	front = (front + 1) % maxSize;
	return elem[front];
}

template <class elemType>
elemType seqQueue<elemType>::getHead()const
{
	return elem[(front + 1) % maxSize];
}

int getMax(int* a, int n) {
	int max = a[0];
	for (int i = 0; i < n; i++) {
		if (a[i] > max) {
			max = a[i];
		}
	}
	return max;
}

struct job {
	int index;
	int priority;
};

int main()
{
	int num, time = 0;
	cin >> num;
	for (int i = 0; i < num; ++i) {
		int n, m;
		cin >> n >> m;
		int* a = new int[n];
		seqQueue<job> queue(n);
		for (int i = 0; i < n; i++) {
			cin >> a[i];
			queue.enQueue(job({ i, a[i] }));
		}

		int max_a = 0;
		while (true) {
			job j = queue.deQueue();
			max_a = getMax(a, n);
			if (j.priority < max_a) {
				queue.enQueue(j);
			}
			else {
				time++;
				a[j.index] = -1;
				if (j.index == m) {
					break;
				}
			}
		}

		cout << time << endl;
		time = 0;
	}
	return 0;
}