CCF CSP认证历年题目自练 Day15

题目一

试题编号： 201709-1
试题名称：打酱油
时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　小明带着N元钱去买酱油。酱油10块钱一瓶，商家进行促销，每买3瓶送1瓶，或者每买5瓶送2瓶。请问小明最多可以得到多少瓶酱油。
输入格式
　　输入的第一行包含一个整数N，表示小明可用于买酱油的钱数。N是10的整数倍，N不超过300。
输出格式
　　输出一个整数，表示小明最多可以得到多少瓶酱油。
样例输入
40
样例输出
5
样例说明
　　把40元分成30元和10元，分别买3瓶和1瓶，其中3瓶送1瓶，共得到5瓶。
样例输入
80
样例输出
11
样例说明
　　把80元分成30元和50元，分别买3瓶和5瓶，其中3瓶送1瓶，5瓶送2瓶，共得到11瓶。

题目分析（个人理解）

输入的n是10的整数倍，先确定不走活动能买几瓶，由于最后求的是最多能买几瓶，所以优先找只要是5的整数倍的情况，然后再找3的整数倍的情况。我用n表示能买几瓶（不算活动）n=int(int(input())/10)
sum用来统计加上送之后的瓶数。先找送两瓶的情况sum=int(n/5)*7然后更新n，再找送1瓶的情况。再更新n,最后算上不可以参加活动的sum+=n，结束！
上代码！！！

n=int(int(input())/10)#能买多少瓶
sum=int(n/5)*7
n=n-int(n/5)*5#减去参与买5送2
sum+=int(n/3)*4
n=n-int(n/3)*3#减去参与买3送1
sum+=n#加上不足以参与促销的
print(sum)

题目二

试题编号： 201709-2
试题名称：公共钥匙盒
时间限制： 1.0s
内存限制： 256.0MB
问题描述：
问题描述
　　有一个学校的老师共用N个教室，按照规定，所有的钥匙都必须放在公共钥匙盒里，老师不能带钥匙回家。每次老师上课前，都从公共钥匙盒里找到自己上课的教室的钥匙去开门，上完课后，再将钥匙放回到钥匙盒中。
　　钥匙盒一共有N个挂钩，从左到右排成一排，用来挂N个教室的钥匙。一串钥匙没有固定的悬挂位置，但钥匙上有标识，所以老师们不会弄混钥匙。
　　每次取钥匙的时候，老师们都会找到自己所需要的钥匙将其取走，而不会移动其他钥匙。每次还钥匙的时候，还钥匙的老师会找到最左边的空的挂钩，将钥匙挂在这个挂钩上。如果有多位老师还钥匙，则他们按钥匙编号从小到大的顺序还。如果同一时刻既有老师还钥匙又有老师取钥匙，则老师们会先将钥匙全还回去再取出。
　　今天开始的时候钥匙是按编号从小到大的顺序放在钥匙盒里的。有K位老师要上课，给出每位老师所需要的钥匙、开始上课的时间和上课的时长，假设下课时间就是还钥匙时间，请问最终钥匙盒里面钥匙的顺序是怎样的？
输入格式
　　输入的第一行包含两个整数N, K。
　　接下来K行，每行三个整数w, s, c，分别表示一位老师要使用的钥匙编号、开始上课的时间和上课的时长。可能有多位老师使用同一把钥匙，但是老师使用钥匙的时间不会重叠。
　　保证输入数据满足输入格式，你不用检查数据合法性。
输出格式
　　输出一行，包含N个整数，相邻整数间用一个空格分隔，依次表示每个挂钩上挂的钥匙编号。
样例输入
5 2
4 3 3
2 2 7
样例输出
1 4 3 2 5
样例说明
　　第一位老师从时刻3开始使用4号教室的钥匙，使用3单位时间，所以在时刻6还钥匙。第二位老师从时刻2开始使用钥匙，使用7单位时间，所以在时刻9还钥匙。
　　每个关键时刻后的钥匙状态如下（X表示空）：
　　时刻2后为1X345；
　　时刻3后为1X3X5；
　　时刻6后为143X5；
　　时刻9后为14325。
样例输入
5 7
1 1 14
3 3 12
1 15 12
2 7 20
3 18 12
4 21 19
5 30 9
样例输出
1 2 3 5 4
评测用例规模与约定
　　对于30%的评测用例，1 ≤ N, K ≤ 10, 1 ≤ w ≤ N, 1 ≤ s, c ≤ 30；
　　对于60%的评测用例，1 ≤ N, K ≤ 50，1 ≤ w ≤ N，1 ≤ s ≤ 300，1 ≤ c ≤ 50；
　　对于所有评测用例，1 ≤ N, K ≤ 1000，1 ≤ w ≤ N，1 ≤ s ≤ 10000，1 ≤ c ≤ 100。

题目分析（个人理解）

首先题目又长又臭！看上去绕来绕去，ok!我还是简单地先看输入，n表示有几个钥匙，k表示有几个老师要拿，那就直接n,k=map(int,input().split()) 然后，再给钥匙盒一个空间，A=[]
for i in range(1,n+1):
A.append(i)
然后就是最关键的核心部分，这里尤其要注意优先级的问题，从头看起，如果老师要取钥匙，肯定是先上课的先去取，多个老师去取不同把钥匙，关键是借和还的时候如果是同一把钥匙注意，先还再取，优先级的问题体现出来了，还有一个，如果有多位老师还钥匙，则他们按钥匙编号从小到大的顺序还。还的时候还是优先放到钥匙盒的最左边。
真是麻烦，我首先考虑的事件的排序可以用lambada函数去判断，但是只是适用于单个元素比较，如果是两个元素可以使用字典存储，配合zip函数再用sorted方法里面匿名函数进行两个元素优先级的比较排序，但是这次我要裂开，要有三个元素去比较，第一个是时间，第二个是钥匙编号，第三个是存还是取的操作。
对于这种复杂的操作，我选择写函数或者类去解决，这样思路比较清晰，我选择写类和方法解决，我定义一个类，key，元素有keyn(钥匙编号)，status(归还还是借钥匙，归还设置为False,借是True),time(归还或者是借钥匙的时间)，存入后按照time,status,keyn的优先级排序刚好满足我的算法条件。
我用一个列表B专门存储所有老师的操作，由于题目个告诉到上课点就借，到下课点就还。那就直接： B.append(key(w,s,True))
B.append(key(w,s+c,False))
关键在于一个如何对三种元素进行排序的问题，我采用python强大的第三方库operator(专门用来构造函数的第三方库，比匿名函数强大的多)


>>> class Student:
...     def __init__(self, name, grade, age):
...         self.name = name
...         self.grade = grade
...         self.age = age
...     def __repr__(self):
...         return repr((self.name, self.grade, self.age))
>>> student_objects = [
...     Student('john', 'A', 15),
...     Student('jane', 'B', 12),
...     Student('dave', 'B', 10),
... ]
>>> sorted(student_objects, key=lambda student: student.age)   # 传统的lambda做法
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]>>> from operator import attrgetter
#注意这个地方的妙用
>>> sorted(student_objects, key=attrgetter('age'))
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
# 但是如果像下面这样接受双重比较，Python脆弱的lambda就不适用了
>>> sorted(student_objects, key=attrgetter('grade', 'age'))

A[0]=1表示一号位置的钥匙是1号钥匙，A[0]=0表示一号位置没钥匙。
上完整代码！！！

import operator
class key:def __init__(self,keyn,time,status):self.keyn=keynself.time=timeself.status=status
n,k=map(int,input().split())#初始化钥匙盒
A=[i+1 for i in range(n)]#迭代生成初始钥匙盒每个钥匙的编码
B=[]#将操作存入列表B
for i in range(k):w,s,c=map(int,input().split())B.append(key(w,s,True))B.append(key(w,s+c,False))
#按照类中的time、status、keyn三个属性对列表排序
cmpfun=operator.attrgetter("time","status","keyn")
B.sort(key=cmpfun)
#按照排序好的操作顺序处理
for b in B:if b.status:#被借走啦，当然要把值设置为0A[A.index(b.keyn)]=0else:for i in range(len(A)):if A[i] ==0:#还钥匙A[i]=b.keynbreak
for i in A:print(i,end=" ")