python ACM模式的输入输出以及刷力扣的常用

1.Python的输入是字符串，所以要自己转类型
2.strip去掉左右两端的空白符，返回str
3.slipt把字符串按空白符拆开，返回[str]
4.map把list里面的值映射到指定类型，返回[type]

使用input

'''多行输入，指定行数'''

n, m = map(int, input().strip().split())#获取第一行，获取第二行可以再写一句同样的语句
#需要矩阵承接数据时
data = []
for i in range(n):
	tmp = list(map(int, input().split()))
	data.append(tmp)

'''多行输入，不指定行数'''
try:
	data = []
	while True:
		line = input().strip() #strip去除左右两边的空白符
		if line == ' ':
			break
		tmp = list(map(int, line.split())) #split按空白符拆开
		data.append(tmp)
expect:
	pass

使用sys.stdin.readline()

如果使用该语句，默认是读取的字符串+’\n’
为了去除末尾’\n’的影响，可以使用strip()
strip()用于去除字符串首尾的字符，默认是空格、\n、\t ，且只能去除首尾的

把input 换成sys.stdin.readline()

import sys
try:
    lis=[]
    while True:
        line=sys.stdin.readline().strip()
        if line =='':
            break
        lines=list(map(int,line.split()))
        lis.append(lines)
    print(lis)
except:
    pass

python做题常用

list

#初始化
l = [0] * len(array)
l=[]

#从后往前访问
l[-1]表示最后一个数
for i in range(0, -10, -1)     #0, -1, -2, -3, -4, -5, -6, -7, -8, -9
for j in reversed(range(len(nums)-1)) #加一个reverse可以直接颠倒

#enumerate 枚举
l = ["a", "b", "c"]
for i, v in enumerate(l):
    print(i, v)
#0 a
#1 b
#2 c 

#map
#可以将参数一一映射来计算， 比如
date = "2019-8-15"
Y, M, D = map(int, date.split('-'))    #Y = 2019, M = 8, D = 15
#map返回的是迭代对象而不是一个列表，要转成列表要加list


#sort
1.调用sort()排序，不会产生新的列表。lst.sort()升序排序
降序排序lst.sort(reverse=True)  升序排序lst.sort()
2.使用内置函数sorted()排序，会产生新的列表对象
lst1=sorted(lst)升序排序   lst2=sorted(lst,reverse=True)降序排序
l1 = [(1,2), (0,1), (3,10) ]
l2 = sorted(l1, key=lambda x: x[0])#按照 tuple 的第一个元素进行排序key允许传入一个自定义参数
# l2 = [(0, 1), (1, 2), (3, 10)]
#排序默认从小到大。可以用reverse=True倒序

#列表生成式 
lst = [i*j for i in range(1,10)]




#ZIP
x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
list(zipped)#[(1, 4), (2, 5), (3, 6)]
```keys(), values(), items()
这三个方法可以分别获得key, value, {key: value}的数组。

#max可以代替if来更新更大的数
maxnums=max(maxnums,tmp)

#多维数组
res = [[], []]
res[0].append()

#extend一次性添加多个元素
lst1.extend(lst2)
#insert在i位置添加x
lst.insert(i, x)

二维列表

ls = [] #二维列表新建可以直接建一个一维列表，后面直接append列表数据就可以了
ls_T = list(map(list, zip(*ls)))# 转置，用于取列元素
if 元素 in ls_T[0]: #判断是不是在0列里面
	j = ls_T[0].index(元素) #第0列中该元素的位置，即多少行
	
	

remove()括号里面不是索引，是具体的数
Pop()括号里面是索引号，索引从1开始

string字符串

ord('a')# 返回单个字符的 unicode:
chr(100)# 返回'd'

#strip和split
'   spacious   '.strip()#strip()移除 string 前后的字符串，默认来移除空格
'1,2,3'.split(',') #['1', '2', '3'],按照某个字符串来切分，返回一个 list,
'1,2,3'.split(',', maxsplit=1)#['1', '2,3'],传入一个参数maxsplit来限定分离数

#将字符串和列表相互转换
字符串转换成列表，注意交换字符需要先转换成列表
#1.list
str1 = '12345'
list1 = list(str1)
print(list1) #['1', '2', '3', '4', '5']
#2.str.split()通过指定分隔符对字符串进行切片
str3 = 'this is string example'
list3 = str3.split('i', 1)
print(list3) #['th', 's is string example']

列表转换成字符串，join里面的可以是list、set
#1.split.join(str),split是指定的分隔符，str是要转换的字符串
list1 = ['1', '2', '3', '4', '5']
str1 = "".join(list1)#12345 

list3 = ['www', 'baidu', 'com']
str3 = ".".join(list3)#www.baidu.com

#是元音
def isVowel(ch:str) -> bool:
            return ch in "aeiouAEIOU"
isVowel(s[i])

deque双端队列

append，添加到末尾
appendleft, 添加到开头
pop, 剔除末尾
popleft，移除开头

set

里面元素不能重复

add : set 的添加是 add 不是append，一次添加一个元素
update：一次添加多个元素

remove vs discard: 都是删除操作，都是删除指定值，区别在于remove不存在的元素会报错，discard不会。
pop：一次删除任意元素

union, intersection: 快速获得并集和交集，方便一些去重操作。
s1.intersection(s2)

用in 和 not in来判断

dict

字典，相当于其它语言中的map, hashtable, hashmap之类的

keys(), values(), items()这三个方法可以分别获得key, value, {key: value}的数组。

#遍历Key
for key in dict:
	print(key)

#遍历value:
for value in dict.values():

#遍历key，value
for key, value in dict.items():

最大, 最小 number

在 python 中分别以 float(‘inf’) 和 float(‘-inf’)表示最大最小值

除法

>>> 3 / 2
1.5
>>> 3 // 2  整除
1

次方

>>> 2 ** 10
1024
pow(x,y)  x的y次方

三项表达式

res = a if condition else b

其它常用函数

round(x)：四舍五入
abs(x)/max()/min()：绝对值/最大值/最小值
range(start=0, stop, step=1])：返回一个可迭代对象，常用于for循环
pow(x, y, [z])：求幂函数x^y，运算完毕可以顺带对z取模
sorted(iterable, key, reverse)：采用Timsort的稳定排序算法，默认升序
int(x, base=10))/float()/str()：转整数(可自定义进制)/转浮点数/转字符串
bin()/oct()/hex()：10进制转二进制(返回0b开头的字符串)/10进制转八进制(返回0开头的字符串)/10进制转十六进制(返回0x开头的字符串)
ord()/chr()：字符转ASCII或ASCII转字符
math.gcd(x,y)：返回x和y的最大公约数

if ……elif……else注意不要用else if 

Counter

count:统计列表中某个元素出现的次数： print("l.count('d') -->", l.count('d'))
统计元素出现的频次，返回一个字典，使用.keys和.values来获取具体的值

from collections import Counter

list1 = ["a", "a", "a", "b", "c", "c", "f", "g", "g", "g", "f"]
dic = Counter(list1)
print(dic)
#结果:次数是从高到低的
#Counter({'a': 3, 'g': 3, 'c': 2, 'f': 2, 'b': 1})
print(dict(dic))
#结果:按字母顺序排序的
#{'a': 3, 'b': 1, 'c': 2, 'f': 2, 'g': 3}

print(dic.items()) #dic.items()获取字典的key和value
#结果:按字母顺序排序的
#dict_items([('a', 3), ('b', 1), ('c', 2), ('f', 2), ('g', 3)])

print(dic.keys())
#结果:
#dict_keys(['a', 'b', 'c', 'f', 'g'])
print(dic.values())
#结果：
#dict_values([3, 1, 2, 2, 3])

print(sorted(dic.items(), key=lambda s: (-s[1])))#默认升序，加负号变成降序
#结果:按统计次数降序排序
#[('a', 3), ('g', 3), ('c', 2), ('f', 2), ('b', 1)]

for i, v in dic.items():
    if v == 1:
        print(i)
#结果:
#b

Round

python3中round()对浮点数的取舍遵循的是四舍六入五平分 ，“五平分”就是根据取舍的位数前的小数奇偶性来判断，奇偶平分。奇数则舍弃，偶数则加一。

四舍五入：from decimal import Decimal
aa = Decimal('2.135').quantize(Decimal('0.00'))#2.14

其他刷题注意的

and or等前后顺序也会影响用例是否通过
可以用in / not in来判断列表、集合等数据结构中是否有某元素
input函数输入的是str类型，若是数，需要转化为int, int(input(‘’))
print(x, end="") end="" 可使输出不换行。

栈与队列

stack = []
stack.append()
stack.pop()

from collections import deque
queen = deque()
queen.append()
queen.popleft()#先入先出

二叉树

前中后遍历是根据根的位置来看的
深度优先搜索:根左右的遍历方式，先遍历一个分支。有点像递归，可以使用栈实现。
广度优先搜索:一层一层遍历，使用队列实现
二叉树有两种存储方式顺序存储，和链式存储，顺序存储就是用数组来存。

#链式存储二叉树的定义
class TreeNode:
    def __init__(self, val, left = None, right = None):
        self.val = val
        self.left = left
        self.right = right