python数据结构与算法练习-Printer Queue

Printer Queue

链接: link.

The only printer in the computer science students’ union is experiencing an extremely heavy workload. Sometimes there are a hundred jobs in the printer queue and you may have to wait for hours to get a single page of output.

Because some jobs are more important than others, the Hacker General has invented and implemented a simple priority system for the print job queue. Now, each job is assigned a priority between 1 and 9 (with 9 being the highest priority,

and 1 being the lowest), and the printer operates as follows.

◎ The first job J in queue is taken from the queue.

◎ If there is some job in the queue with a higher priority than job J, thenmove J to the end of the queue without printing it.

◎ Otherwise, print job J (and do not put it back in the queue).

In this way, all those importantmuffin recipes that the Hacker General is printing get printed very quickly. Of course, those annoying term papers that others are printing may have to wait for quite some time to get printed, but that’s life.

Your problem with the new policy is that it has become quite tricky to determine when your print job will actually be completed. You decide to write a program to figure this out. The program will be given the current queue (as a list of priorities) as well as the position of your job in the queue, and must then calculate how long it will take until your job is printed, assuming that no additional jobs will be added to the queue. To simplifymatters, we assume that printing a job always takes exactly one minute, and that adding and removing jobs from the queue is instantaneous.

输入格式
One line with a positive integer: the number of test cases (at most 100). Then for each test case:

◎ One line with two integers n and m, where n is the number of jobs in the queue (1 ≤ n ≤ 100) and m is the position of your job (0 ≤ m ≤ n −1). The first position in the queue is number 0, the second is number 1, and so on.

◎ One linewith n integers in the range 1 to 9, giving the priorities of the jobs in the queue. The first integer gives the priority of the first job, the second integer the priority of the second job, and so on.

输出格式
For each test case, print one line with a single integer; the number of minutes until your job is completely printed, assuming that no additional print jobs will arrive.

样例

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

output
1
2
5

题意：本题题意就是在队列中优先级高的数值先输出的情况下，给定一个目标值以及目标队列，直到输出目标值时需要的次数。（一个输出记为一次）

思路：
1.创建双端队列
2.用while循环，判定条件队列不为空即可
3.对于popleft（），如果其值小于当前最大值，则放队尾
4.如果等于最大值 则出队，计数加一

遇到的问题：
1.队列中的值有与给定值相同的值的时候，怎么确定出队的是给定的值
2.怎么确定j及时变化的队列中当前优先级的最大值
（这两点是我自己做题时遇到的问题，特此记录以免忘记）
解决方案：

1. 采用zip记录给定队列以及目标值的下标，在将元组列表存为队列，这样while跳出循环的条件即可将popleft()[0][0]和popleft()[0]分别与当前最大值和目标值分别对比，满足即跳出循环。
2. 每循环一次就把给定的输入列表排序一次，当最大值被打印出一次，便将最大值pop（）,并重新排序列表，这样保证每次列表的[-1]都是当前最大值。

python实现

from collections import deque
case_n = int(input())

while True:
    try:
        n,m = map(int,input().split())
        l = list(map(int,input().split()))


        def cul_time(n, m, l):
            num = []
            qu = deque()
            for i in range(n):
                num.append(i)
            zipped = zip(l, num)

            for i in zipped:
                qu.append(i)
            # qu = [(1,0),(2,1)(3,2)(4,3)]

            stop = (l[m], m)
            # stop = （3,2）

            sum = 0
            while len(qu) > 0:
                l.sort()
                ma = l[-1]
                if qu[0][0] == ma and qu[0] == stop:  # 跳出条件 当前最大值等于给定的目标值
                    sum += 1
                    break
                if qu[0][0] == ma:
                    qu.popleft()
                    del (l[-1])
                    sum += 1
                elif qu[0][0] < ma:
                    qu.append(qu.popleft())
            return sum


        print(cul_time(n, m, l))
    except:
        break

需要注意的知识点：

这里有用到了如下结构解题：一直处理多个案例到不再有输入

while True:
	try:
	'''
	'''
	except:
		break

仅记录刷题过程以及需要注意的知识点，方便自己复习。