华为机试题：HJ16 购物单（python）

描述：

输入描述：

输出描述： 输出一个正整数，让张强获得最大满意度。

示例1

输入：
1000 5
800 2 0
400 5 1
300 5 1
400 3 0
500 2 0
输出：
2200

示例2

输入：
50 5
20 3 5
20 3 5
10 3 0
10 2 0
10 1 0
输出：
130
说明：

Python3

import collections
import functools
##################################################
# （1）获取输入
n, m = map(int,input().strip().split())
v = [0] * m		# 重复操作符（价格）
p = [0] * m		# 重复操作符（满意度）
q = [0] * m		# 重复操作符（主件、附件编号）
##################################################
# （2）获取附件的编号
d = collections.defaultdict(list)
# collections.defaultdict(default_factory):如果该变量存在，则初始化；如果没有，则为None。其他功能与dict相同。
# 使用list作为参数，可以将键值对序列转换为列表字典。

for i in range(m):				# 遍历所有附件（包括：主件、附件）
    temm = list(map(int,input().strip().split()))		# 获取输入
    v[i], p[i],q[i] = temm[0],temm[1],temm[2]-1			# 获取价格、重要度、主附件编号（编号全部减一，下标从0开始）
    if q[i] != -1:				# -1：表示主件	其余值：表示附件
        d[q[i]].append(i)		# 保存所有附件物品的编号（在多个附件中，将相同编号的附件存放在一个value中）
##################################################
# （3）保存各种组合的价格、满意度
dn = collections.defaultdict(list)
for k in d.keys():				# 遍历字典key	
    dn[k].append([v[k],v[k]*p[k]])										# 保存（附件）的价格、满意度
    for i in d[k]:				# 遍历字典key对应的value（列表类型）		
    # cc1 = v[k]						# key值对应的附件
    # cc2 = v[i]						# key对应的value值的附件
        dn[k].append([v[i]+v[k],v[i]*p[i]+v[k]*p[k]])					# 保存（两两附件）的价格、满意度
        
    if len(d[k]) == 2:			# 若key对应的value有两个（列表类型）
    	# 每个主件可以有0个、1个、2个附件，附件不再有从属于自己的附件。 
        # c1 = v[d[k][0]]				# key值对应的附件
   		# c2 = v[i]						# key对应的value值的附件
   		# c3 = v[d[k][1]]				# key对应的value值的附件
        dn[k].append([v[d[k][0]] + v[k] + v[d[k][1]], 					# 保存（三个附件）的价格、满意度
        		     v[d[k][0]] * p[d[k][0]] + v[k] * p[k] + v[d[k][1]] * p[d[k][1]]])

for i in range(m):
    if i not in d and q[i] == -1:
        dn[i].append([v[i],v[i]*p[i]])									# 保存（主件）的价格、满意度

##################################################
# （4）打印输出
@functools.cache
def f(i,n):
    if n < 0: return 0
    if i < 0: return 0
    res=f(i-1, n)				# 递归循环（初始化为0）
    
    for v, vp in dn[k[i]]:		# 遍历key对应的多个value，获取对应的价格、满意度
        if v > n: continue 		# 若价格大于总额，舍弃 
        res = max(res, f(i-1, n-v) + vp)		# 递归循环（遍历所有满足条件的附件，并获取最大满意度）
    return res
     
k = list(dn.keys())				# 获取字典的key值，并转换为列表类型
print(f(len(k)-1, n))			

'''
输入：
1000 5
800 2 0 
400 5 1
300 5 1
400 3 1
500 2 4

输出：
2200
'''    
   

• input()：获取控制台（任意形式）的输入。输出均为字符串类型。
• strip()：删除字符串（开头 / 结尾）指定字符（默认空格）或字符序列，但不能删除中间部分的字符。
• split()：通过指定分隔符（默认为空格）对字符串进行切片，并返回分割后的字符串列表（list）。
• int() ：将一个字符串或数字转换为十进制整数（强转）。输入可以指定进制，默认十进制。
• map()：根据给定函数对指定序列进行映射。即把传入函数依次作用到序列的每一个元素，并返回新的序列。
• list()：创建列表。将任意可迭代序列转换为列表类型，并返回转换后的列表。
• range() ：输出指定范围内的所有值（前闭后开）。
• list.append() ：向列表末尾添加任意类型元素。
• len()：返回字符串、列表、字典、元组等的长度。
• max() ：返回序列中的最大值。
• print() ：打印输出。

---

知识点详解

1、input()：获取控制台（任意形式）的输入。输出均为字符串类型。

【Python】input()函数用法小结

备注：输入可以是任意形式，不限制数据类型。
备注：无论输入是什么，输出都是字符串类型。

print('整型: ', input())
##########################
str1 = input()
print('任意形式: ', str1)
print(type(str1))
'''
123
整型:  123
asd123!@#
任意形式:  asd123!@#

'''

2、print() ：打印输出。

【Python】print()函数的用法

3、strip()：删除字符串（开头 / 结尾）指定字符（默认空格）或字符序列，但不能删除中间部分的字符。

函数说明：str3 = str1.strip(str2)
其中，str1是操作字符串，str2是待移除指定的字符或字符序列。str3是移除后生成的新字符串。

str_temp1 = "  123 ABCDEFG 321"
str_temp2 = "  123 ABCDEFG 321"
str_temp3 = "  123 ABCDEFG 321"
print(str_temp1.strip())            # 【输出结果】"123 ABCDEFG 321"
print(str_temp2.strip('12'))        # 【输出结果】"  123 ABCDEFG 321  "
print(str_temp3.strip('3'))         # 【输出结果】"  123 ABCDEFG 321  "

4、split()：通过指定分隔符（默认为空格）对字符串进行切片，并返回分割后的字符串列表（list）。

函数说明：str.split(str=".", num=string.count(str))[n]
参数说明：

• str： 表示分隔符，默认为空格，但是不能为空。若字符串中没有分隔符，则把整个字符串作为列表的一个元素。
• num：表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量。
• [n]： 表示选取第n个切片。
  • 注意：当使用空格作为分隔符时，对于中间为空的项会自动忽略。

s = 'www.dod.com.cn'
print('分隔符(默认): ', s.split())                    # 【输出结果】分隔符(默认):  ['www.dod.com.cn']
print('分隔符(.): ', s.split('.'))                   # 【输出结果】分隔符(.):  ['www', 'dod', 'com', 'cn']
print('分割1次, 分隔符(.): ', s.split('.', 1))        # 【输出结果】分割1次, 分隔符(.):  ['www', 'dod.com.cn']
print('分割2次, 分隔符(.): ', s.split('.', 2))        # 【输出结果】分割2次, 分隔符(.):  ['www', 'dod', 'com.cn']
print('分割2次, 分隔符(.), 取出分割后下标为1的字符串: ', s.split('.', 2)[1])      # 【输出结果】分割2次, 分隔符(.), 取出分割后下标为1的字符串:  dod
print(s.split('.', -1))                             # 【输出结果】['www', 'dod', 'com', 'cn']
###########################################
# 分割2次, 并分别保存到三个变量
s1, s2, s3 = s.split('.', 2)
print('s1:', s1)                                    # 【输出结果】s1: www
print('s2:', s1)                                    # 【输出结果】s2: www
print('s3:', s2)                                    # 【输出结果】s3: dod
###########################################
# 连续多次分割
a = 'Hello<[www.dodo.com.cn]>Bye'
print(a.split('['))                                 # 【输出结果】['Hello<', 'www.dodo.com.cn]>Bye']
print(a.split('[')[1].split(']')[0])                # 【输出结果】www.dodo.com.cn
print(a.split('[')[1].split(']')[0].split('.'))     # 【输出结果】['www', 'dodo', 'com', 'cn']

5、int() ：将一个字符串或数字转换为十进制整数（强转）。输入可以指定进制，默认十进制。

【Python】int()用法详解

函数说明：int(x, base=10)
输入参数：

• x：字符串或数字。
• base：参数x为（二进制、八进制、十进制、十六进制）数，默认十进制数。
  备注：若带参数base，则输入必须是整数，且整数必须以字符串的形式进行输入。如：整数12转化为16进制，int('12', base=16)
  10进制转化为16进制的算法

输入	返回值
int()	整数 0
int(整数)	整数
int(浮点数)	浮点数的整数
int(字符串(整数))	将字符串类型转换为int类型转换
int(字符串(浮点数))	需先转换为float类型，再进行int转换，否则报错。
–	–
int('整数', base=16)	将输入的16进制整数转换为10进制整数（同理：其余进制）

print(int())                    # 【输出结果】0
print(int(2))                   # 【输出结果】2
print(int(-2.9))                # 【输出结果】-2
print(int('-2'))                # 【输出结果】-2
print(int(float('-2.9')))       # 【输出结果】-2

print(int('20', 16))       		# 【输出结果】32
print(int('0XAA', 16))       	# 【输出结果】170

6、map()：根据给定函数对指定序列进行映射。即把传入函数依次作用到序列的每一个元素，并返回新的序列。

函数说明：map(function, iterable)
输入参数：

• function：自定义函数。
• iterable：可迭代序列

print('将元组转换为list（返回一个迭代器）: ', map(int, (1, 2, 3)))
print('将元组转换为list（使用list()转换为列表）: ', list(map(int, (1, 2, 3))))

print('将字符串转换为list: ', list(map(int, '1234')))
print('将字典中的key转换为list: ', list(map(int, {1: 2, 2: 3, 3: 4})))

'''
将元组转换为list（返回一个迭代器）:  

7、list()：创建列表。将任意可迭代序列转换为列表类型，并返回转换后的列表。

函数说明：list(object)

• object：待转换为列表的任意可迭代序列（可省略）。若参数为空：list() 表示创建一个空列表。

备注1：参数必须是可迭代序列对象，否则系统报错。
备注2：将字典转换为列表时，默认只输出key，即默认形式：dict.keys()，而舍去value。若想将字典的值转换为列表，可以使用dict.values()。

# （1）创建一个空列表
test1 = list()
print(test1)                            # 【输出结果】[]
#################################################################
# （2）【字符串】转换为列表
test2 = list('cat')
print(test2)                            # 【输出结果】['c', 'a', 't']
#################################################################
# （3）【元组】转换为列表
test3 = list(('I love Python.', 'I also love HTML.'))
print(test3)                            # 【输出结果】['I love Python.', 'I also love HTML.']
#################################################################
# （4）【字典】转换为列表
test4 = list({'China': 'Beijing', 'Russia': 'Moscow'})
test44 = list({'China': 'Beijing', 'Russia': 'Moscow'}.keys())      
test444 = list({'China': 'Beijing', 'Russia': 'Moscow'}.values())
print(test4)                            # 【输出结果】['China', 'Russia']
print(test44)                           # 【输出结果】['China', 'Russia']
print(test444)                          # 【输出结果】['Beijing', 'Moscow']
#################################################################
# （5）【集合】转换为列表
test5 = list({1, 4, 'sdf'})
print(test5)                            # 【输出结果】[1, 4, 'sdf']
#################################################################
# （6）【列表】转换为列表
test6 = list(["a", "b", "c", "d"])
print(test6)                            # 【输出结果】['a', 'b', 'c', 'd']
#################################################################
# （7）【可迭代序列（range类型）】转换为列表
test7 = list(range(10))
print(test7)                            # 【输出结果】[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#################################################################
# （8）【可迭代序列（map类型）】转换为列表
test8 = list(map(int, [23.2, 33.1]))
print(test8)                            # 【输出结果】[23, 33]

8、range() ：输出指定范围内的所有值（前闭后开）。

函数说明：range(start=0，stop，step=1)
输入参数：

• start：序列的起始点，默认值0。
• stop：序列的终止点。
• step：滑动步长，默认为1。正数表示迭代上升，负数表示迭代下降。

备注：前闭后开[A，B)，即可以取到A值，但取不到B值。

# （1）指定stop=9, start默认为0，step默认为1
for i in range(9):
    print('A =', i)
'''
A = 0
A = 1
A = 2
A = 3
A = 4
A = 5
A = 6
A = 7
A = 8
'''
# （2）指定start=2, stop=9, step默认为1
for i in range(2, 9):
    print('B =', i)
'''
B = 2
B = 3
B = 4
B = 5
B = 6
B = 7
B = 8
'''
# （3）指定start=2, stop=9, step=-2
for i in range(9, 2, -2):
    print('C =', i)
'''
C = 9
C = 7
C = 5
C = 3
'''

9、list.append() ：向列表末尾添加任意类型元素。

函数说明：list.append( element )
输入参数：

• element ：任何类型的元素。

注意1：只能向列表末尾添加元素，而不是任意位置。
注意2：将列表A添加到列表B，添加的是 “引用地址” 而不是内容本身，故当被列表A发生变化时，添加后的列表B也会同步发生变化。 解决方法：深拷贝copy.deepcopy(list(A))后进行添加。

import copy：导入模块
浅拷贝copy.copy(list(A))：拷贝这个对象的引用地址
深拷贝copy.deepcopy(list(A))：拷贝对象的内容。

# （1）添加任意类型元素
list1 = ['A', 'B', 2]
list1 .append({'key': 1})
print(list1)
############################################################
# （2）列表同步：若添加的列表A发生改变，被添加的列表B同步改变。
list2 = ['A', 'B', 2]
list22 = [1, 3]
list2.append(list22)
print(list2)
list22.append('Z')
print(list2)
############################################################
# （2）深拷贝：若添加的列表A发生改变，被添加的列表B不会改变。
import copy
list3 = ['A', 'B', 2]
list33 = [1, 3]
list3.append(copy.deepcopy(list33))
print(list3)
list33.append('Z')
print(list3)

'''
['A', 'B', 2, {'key': 1}]
['A', 'B', 2, [1, 3]]
['A', 'B', 2, [1, 3, 'Z']]
['A', 'B', 2, [1, 3]]
['A', 'B', 2, [1, 3]]
'''

10、len()：返回字符串、列表、字典、元组等的长度。

函数说明：len(object)

str_temp = "Hello, boy !"
print(len(str_temp))                    # 【输出结果】12
#############################################
list_temp = ['h', 'e', 'l', 'l', 'o']
print(len(list_temp))                   # 【输出结果】5
#############################################
dict_temp = {'num': 520, 'name': "do do"}
print(len(dict_temp))                   # 【输出结果】2
#############################################
tuple_temp = ('G', 'o', 'o', 'd')
print(len(tuple_temp))                  # 【输出结果】4

11、max() ：返回序列中的最大值。