文章目录

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

描述：

输入描述：

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

示例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
n,m = map(int,input().strip().split())
v = [0]*m
p = [0]*m
q = [0]*m
d = collections.defaultdict(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
    if q[i] != -1:
        d[q[i]].append(i)

dn = collections.defaultdict(list)
for k in d.keys():
    dn[k].append([v[k],v[k]*p[k]])
    for i in d[k]:
        dn[k].append([v[i]+v[k],v[i]*p[i]+v[k]*p[k]])
    if len(d[k]) == 2:
        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]])

k = list(dn.keys())
@functools.cache
def f(i,j):
    if j < 0: return 0
    if i < 0: return 0
    
    res=f(i-1,j)
    for v,vp in dn[k[i]]:
        if v>j:continue
        res = max(res,f(i-1,j-v)+vp)
    return res
     

print(f(len(k)-1,n))

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!@#
<class 'str'>
'''

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（返回一个迭代器）:  <map object at 0x0000018507A34130>
将元组转换为list（使用list()转换为列表）:  [1, 2, 3]

将字符串转换为list:  [1, 2, 3, 4]
将字典中的key转换为list:  [1, 2, 3]
'''

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