コンテストでよく使われる標準ライブラリを解析し、コードテンプレートを提供
目次
1.2 lru_cache (メモリストレージ、戻り速度の高速化)
1.関数ツール
1.1 cmp_to_key
古いスタイルの比較関数をキー関数に変換します。
-1 変更なし 1 位置を交換
import functools
x=[1,3,2,4,5]
def cmp_rise(a,b):
'''
升序排序：
当前面的参数a小于后面的参数b返回-1，-1代表保持不变，
当前面的的参数a大于等于后面的参数b返回1，1代表交换顺序。
因此保证了前面的数子小于后面的数字，是升序排序。
'''
if a <b:
return -1
else:
return 1
def cmp_decline(a,b):
'''
降序排序：
当前面的参数a小于后面的参数b返回1，1代表交换顺序，
当前面的的参数a大于等于后面的参数b返回-1，-1代表保持不变。
因此保证了前面的数子大于后面的数字，是降序排序。
'''
if a <b:
return 1
else:
return -1
x_sorted_by_rise=sorted(x,key=functools.cmp_to_key(cmp_rise))
x_sorted_by_decline=sorted(x,key=functools.cmp_to_key(cmp_decline))
print(x) # 输出结果：[1, 3, 2, 4, 5]
print(x_sorted_by_rise) # 输出结果：[1, 2, 3, 4, 5]
print(x_sorted_by_decline) # 输出结果：[5, 4, 3, 2, 1]
1.2 lru_cache (メモリストレージ、戻り速度の高速化)
関数の戻り値をすばやくキャッシュまたはキャッシュ解除できるようにします。
このデコレータは、関数の呼び出し結果をキャッシュするために使用されます。複数回呼び出す必要がある関数の場合、各呼び出しのパラメータが同じであるため、このデコレータを使用して呼び出し結果をキャッシュし、それによってプログラムを高速化できます。 。
デコレータはさまざまな呼び出し結果をメモリにキャッシュするため、メモリの使用量に注意する必要があります。
from functools import lru_cache
@lru_cache(maxsize=30) # maxsize参数告诉lru_cache缓存最近多少个返回值
def fib(n):
if n < 2:
return n
return fib(n-1) + fib(n-2)
print([fib(n) for n in range(10)])
fib.cache_clear() # 清空缓存2.コレクション
2.1と
両端キュー。単調キューと BFS 検索の実装に使用されます。
from collections import deque
q = deque(['a', 'b', 'c'], maxlen=10)
# 从右边添加一个元素
q.append('d')
print(q) # deque(['a', 'b', 'c', 'd'], maxlen=10)
# 从左边删除一个元素
print(q.popleft()) # a
print(q) # deque(['b', 'c', 'd'], maxlen=10)
# 扩展队列
q.extend(['i', 'j'])
print(q) # deque(['b', 'c', 'd', 'i', 'j'], maxlen=10)
# 查找下标
print(q.index('c')) # 1
# 移除第一个'd'
q.remove('d')
print(q) # deque(['b', 'c', 'i', 'j'], maxlen=10)
# 逆序
q.reverse()
print(q) # deque(['j', 'i', 'c', 'b'], maxlen=10)
# 最大长度
print(q.maxlen) # 10
2.1.1 モノトーンアライメントの実装
ブルーブリッジカップMAX最高値差
import os
import sys
# 请在此输入您的代码
from collections import deque
def findMaxdiff(n,k,a):
q1,q2=deque(),deque() # 建两个单调队列
res=-sys.maxsize
for i in range (n): # 遍历每一个元素
while q1 and a[q1[-1]]>=a[i]: #q1有元素且最后一个元素都大于a[i]
q1.pop()
q1.append(i)
while q1 and i-q1[0]>=k:
q1.popleft()
Fi=a[q1[0]]
while q2 and a[q2[-1]]<=a[i]: #q1有元素且最后一个元素都大于a[i]
q2.pop()
q2.append(i)
while q2 and i-q2[0]>=k:
q2.popleft()
Gi=a[q2[0]]
#计算最大差值
res=max(res,Gi-Fi)
return res
n,k=map(int,input().split())
A=list(map(int,input().split()))
print(findMaxdiff(n,k,A))2.1.2 BFS ワイド検索
ブルーブリッジカップリアルクエスチョンジャンプバッタ
import collections
import sys
meet=False #判断是否相遇
def extend(q,m1,m2):
global meet
s=q.popleft()
ss=list(s)
index=ss.index('0') #找0的索引
for j in [1,-1,2,-2]:
ss[(index+j+9)%9],ss[index]= ss[index],ss[(index+j+9)%9]
a=''.join(ss)
if a in m2: # 找到相同的了，即相遇了
print(m1[s]+1+m2[a])
meet=True
return
if a not in m1:
q.append(a)
m1[a]=m1[s]+1 # 向字典中添加
ss[(index+j+9)%9],ss[index]= ss[index],ss[(index+j+9)%9]
# meet=False
q1=collections.deque()
q2=collections.deque()
q1.append("012345678")
q2.append("087654321")
# 字典去重，同时记录步数
mp1={'012345678':0} ; mp2={'087654321':0}
while q1 and q2 : # 两个都不为空
if len(q1)<=len(q2): extend(q1,mp1,mp2)
else: extend(q2,mp2,mp1)
if meet==True: break
3.sys
3.1 sys.maxsize
オペレーティング システムが保持する最大 int 値を示します。
3.2 sys.exit()
プログラム実行の中断
3.3 sys.stdin.readline()
すぐに読んでください。キャリッジ リターン文字に注意してください。これはあまり役に立たず、効率もあまり向上しません。
import sys
a = sys.stdin.readline()
b = input()
print(len(a), len(b))
a = sys.stdin.readline().strip('\n')
b = input()
print(len(a), len(b))
输出结果
123123 123123 adsfasdfd fefeggegeag fasdfa
123123 123123 adsfasdfd fefeggegeag fasdfa
43 42
123123 123123 adsfasdfd fefeggegeag fasdfa
123123 123123 adsfasdfd fefeggegeag fasdfa
42 423.4 sys.setrecursionlimit()
最大再帰深さを設定します。デフォルトは非常に小さく、dfs がセグメント エラーを報告する場合があります。
sys.setrecursionlimit(10**6)4.ヒープク
4.1 heapq.heapify(x)
リスト x をその場で線形時間でヒープに変換します。
import heapq
H = [21,1,45,78,3,5]
# Use heapify to rearrange the elements
heapq.heapify(H)
print(H)
[1, 3, 5, 78, 21, 45]
4.2 heapq.heappush(ヒープ, アイテム)
ヒープの不変性を維持しながら、 item の値をヒープに追加します。
# Add element
heapq.heappush(H,8)
print(H)
[1, 3, 5, 78, 21, 45]
↓
[1, 3, 5, 78, 21, 45, 8]
4.3 heapq.heappop(ヒープ)
ヒープを不変に保ちながら、ヒープの最小要素をポップして返します。ヒープが空の場合、IndexError がスローされます。heap[0] を使用すると、ポップせずに最小の要素のみにアクセスできます。
# Remove element from the heap
heapq.heappop(H)
print(H)
[1, 3, 5, 78, 21, 45, 8]
↓
[3, 21, 5, 78, 45]
4.4 ヒープ最適化された Dijstra
1. ブルーブリッジカップ全国大会本題出張
import os
import sys
import itertools
import heapq
# Bellman-Ford O(mn)
'''
n,m=map(int,input().split())
stay=[0]+list(map(int,input().split()))
stay[n]=0 # 终点不需要隔离
e=[]
for i in range(m):
a,b,c=map(int,input().split())
e.append([a,b,c])
e.append([b,a,c])
dp=[sys.maxsize for i in range(n+1)]
dp[1]=0 #到起点的距离为0
for i in range(1,n+1): # n个点
for j in e: # m条边
v1,v2,cost=j
#if v2==n: # n号城市不需要隔离时间
dp[v2]=min(dp[v2],dp[v1]+cost+stay[v2])
print(dp[n])
'''
# Dijstra 临接表写法 O(n*n)
'''
n,m=map(int,input().split())
stay=[0]+list(map(int,input().split()))
stay[n]=0 # 终点不需要隔离
edge=[[]for i in range(n+1)]
for i in range(m):
a,b,c=map(int,input().split())
edge[a].append([b,c+stay[b]])
edge[b].append([a,c+stay[a]])
hp=[]
vis=[0 for i in range(n+1)]
dp=[sys.maxsize for i in range(n+1)]
dp[1]=0 # 自身到自身距离为0
heapq.heappush(hp,(0,1))
while hp:
u=heapq.heappop(hp)[1]
if vis[u]:
continue
vis[u]=1
for i in range(len(edge[u])): # 遍历u的边
v,w=edge[u][i][0],edge[u][i][1]
if vis[v]:
continue
if dp[v]>dp[u]+w:
dp[v]=dp[u]+w
heapq.heappush(hp,(dp[v],v))
print(dp[n])
'''
# Dijstra临接矩阵写法 O(n*n)
'''
n,m=map(int,input().split())
stay=[0]+list(map(int,input().split()))
stay[n]=0 # 终点不需要隔离
edge=[[sys.maxsize for i in range(n+1)]for i in range(n+1)]
for i in range(m):
a,b,c=map(int,input().split())
edge[a][b]=c+stay[b]
edge[b][a]=c+stay[a]
vis=[0 for i in range(n+1)]
dp=[sys.maxsize for i in range(n+1)]
dp[1]=0 # 自身到自身距离为0
for i in range(n-1): #只需要处理n-1个点
t=-1
for j in range(1,n+1): # 找到没处理过得并且距离最小的
if vis[j]==0 and(t==-1 or dp[j]<dp[t] ):
t=j
for j in range(1,n+1):
dp[j]=min(dp[j],dp[t]+edge[t][j])
vis[t]=1
print(dp[n])
'''
# SPFA
n,m=map(int,input().split())
stay=[0]+list(map(int,input().split()))
stay[n]=0 # 终点不需要隔离
edge=[[]for i in range(n+1)] #临接表存边
for i in range(m):
a,b,c=map(int,input().split())
edge[a].append([b,c+stay[b]])
edge[b].append([a,c+stay[a]])
dp=[sys.maxsize for i in range(n+1)]
dp[1]=0 # 自身到自身距离为0
def spfa():
hp=[]
heapq.heappush(hp,1) #用堆实现相当于优先队列，加快一点效率罢了
in_hp=[0 for i in range(n+1)] # 标记数组换为了判断是否在队列中
in_hp[1]=1 # 1在队列
while hp:
u=heapq.heappop(hp)
in_hp[u]=0 # 标记为不在队列
if dp[u]==sys.maxsize: # 没有处理过的点，直接跳过，只处理邻居点
continue
for i in range(len(edge[u])): # 遍历u的边
v,w=edge[u][i][0],edge[u][i][1]
if dp[v]>dp[u]+w:
dp[v]=dp[u]+w
if in_hp[v]==0: # 他的邻居不再队列，就把他入队，方便下下次更新邻居的邻居结点
heapq.heappush(hp,v)
in_hp[v]=1
spfa()
print(dp[n])4.5 ヒープによって実現されるクラスカルのアルゴリズム
1. 全国大会の実問に力を入れる
import os
import sys
import math
import heapq # heapq 比 优先队列要快很多
input = sys.stdin.readline
n = int(input().strip())
root = [i for i in range(n+1)]
arr = [list(map(int, input().strip().split())) for i in range(n)] # n个点坐标 高度
# 计算距离
def dist(x1,y1,h1, x2,y2,h2):
return math.sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2)) + (h1-h2)*(h1-h2)
q = []
# 建立 n个点的的连通图
for i in range(n):
for j in range(i+1,n):
heapq.heappush(q, [dist(arr[i][0],arr[i][1],arr[i][2], arr[j][0],arr[j][1],arr[j][2]), i, j]) # 从 i到j牵线，并按距离排序
# 判断是否会形成环
def find(u):
if u != root[u]:
root[u] = find(root[u])
return root[u]
# Kruskal 算法实现步骤
def Kruskal():
ans = 0.00
cnt = 0
while q and cnt < n-1: # 图只需找n-1条边
c,a,b = heapq.heappop(q)
a_root = find(a)
b_root = find(b)
if a_root != b_root:
root[a_root] = b_root
ans += c
cnt += 1
print('%.2lf' % ans)
Kruskal()
"""
import os
import sys
# 请在此输入您的代码
import math
n=int(input())
def money(a,b):
ke=math.sqrt(pow(a[0]-b[0],2)+pow(a[1]-b[1],2))+pow(a[2]-b[2],2)
return ke
def prim():
global res
dist[0]=0
book[0]=1
for i in range(1,n):
dist[i]=min(dist[i],G[0][i])
for i in range(1,n):
cnt=float("inf")
t=-1
for j in range(1,n):
if book[j]==0 and dist[j]<cnt:
cnt=dist[j]
t=j
if t==-1 :
res=float("inf")
return
book[t]=1
res+=dist[t]
for j in range(1,n):
dist[j]=min(dist[j],G[t][j])
ls=[]
book=[0]*n
dist=[float("inf")]*n
res=0
for i in range(n):
ls.append(list(map(int,input().split())))
G=[[float("inf")]*n for _ in range(n)]
for i in range(n):
G[i][i]=float("inf")
for i in range(n):
for j in range(i+1,n):
G[i][j]=money(ls[i],ls[j])
G[j][i]=money(ls[i],ls[j])
prim()
print("{:.2f}".format(res))
"""5.itertools
主に組み合わせやコンビネーションを使います。
5.1 組み合わせ
itertools.combinations(iterable, r): 反復可能なオブジェクトの長さ r のすべての組み合わせを生成します。
5.2 順列
itertools.permutations(iterable, r=None): 反復可能オブジェクトの長さ r のすべての順列を生成します。デフォルトの r は反復可能オブジェクトの長さです。
5.3 例
1. 数学の問題
import os
import sys
import itertools
# 请在此输入您的代码
L=[str(i) for i in range(1,10)]
ans=0
for i in itertools.permutations(L):
s=''.join(i)
if int(s[:3])+int(s[3:6])==int(s[6:]):
ans+=1
print(ans)6.二等分する
順序付けされた配列の挿入および検索のための組み込みの二分探索機能
6.1 bisect_left()
bisect.bisect_left(a, x, lo=0, hi=len(a))
x ∈ a の場合は x の左端のインデックスを返し、それ以外の場合は x の右隣のインデックスを返し、挿入後に x がその左側に配置されるようにします。
6.2 bisect_right() 、bisect()
bisect.bisect(a, x, lo = 0, hi =len(a))
bisect.bisect_right(a, x, [lo=0, hi=len(a)])
x ∈ a の場合は x の左端のインデックスを返し、それ以外の場合は x の右隣のインデックスを返し、挿入後に x がその左側に配置されるようにします。
6.3 insort_left()
bisect.insort_left(a, x, lo=0, hi=len(a))
bisect.bisect_left()シーケンス a 内の 要素 x の挿入点 (左側)
を検索します。 bisect.insort_left() は、挿入点の検索に基づいて要素 x をシーケンス a に挿入し、要素の順序を維持したままシーケンス a を変更します。
6.4 insort_right()、insort()
bisect.insort(a, x, lo=0, hi=len(a))
bisect.insort_right(a, x, lo=0, hi=len(a))
6.5 例
import bisect
nums = [0,1,2,3,4,4,6]
idx = bisect.bisect_left(nums,-1) # 0
idx = bisect.bisect_left(nums,8) # 7
idx = bisect.bisect_left(nums,3) # 3
idx = bisect.bisect_left(nums,3.5) # 4
idx = bisect.bisect_left(nums,4) # 4
idx = bisect.bisect_left(nums,3,1,4) # 3
a = [1,4,6,8,12,15,20]
position = bisect.bisect(a,13)
print(position) # 5
# 用可变序列内置的 insert 方法插入
a.insert(position, 13)
print(a) # 5 [1, 4, 6, 8, 12, 13, 15, 20]
探している番号はリストにありません
import bisect
list1 = [1,3,5,7,9,11,11,11,11,11,13]
a = bisect.bisect(list1,6)
b = bisect.bisect_left(list1,6)
c = bisect.bisect_right(list1,6)
print(a,b,c)
# 输出为 3，3，3検索された番号はリスト内で 1 つだけです
import bisect
list1 = [1,3,5,7,9,11,11,11,11,11,13]
a = bisect.bisect(list1,9)
b = bisect.bisect_left(list1,9)
c = bisect.bisect_right(list1,9)
print(a,b,c)
# 输出 5，4，5検索された番号がリスト内に複数あります
import bisect
list1 = [1,3,5,7,9,11,11,11,11,11,13]
a = bisect.bisect(list1,11)
b = bisect.bisect_left(list1,11)
c = bisect.bisect_right(list1,11)
print(a,b,c)
# 输出是 10，5，106.6 例 1 最長の昇順部分列
1. ブルーブリッジナイツ
import os
import sys
'''
# 最长上升子序列
n = int(input())
a = list(map(int,input().split()))
f = [1]*n
for i in range(1,n):
for j in range(i):
if a[i] > a[j]:
f[i] = max(f[i],f[j]+1)
print(max(f))
'''
# 超时
'''
import bisect
n = int(input())
a = list(map(int,input().split()))
b = [a[0]]
for i in range(1,n):
t = bisect.bisect_left(b,a[i])
# 若b中不存在a[i]，t是适合插入的位置
# 若b中存在a[i]，t是a[i]第一个出现的位置
if t == len(b): # 插入的位置是否是末尾
b.append(a[i])
else:
b[t] = a[i]
print(len(b))
'''
import bisect
#蓝桥骑士 dp lis(Longest Increasing Subsequence)
n = int(input())
alist = list(map(int,input().split()))
dp = []
for i in alist:
if not dp or i > dp[-1]:
dp.append(i)
else:
index = bisect.bisect_left(dp,i)
dp[index]=i
print(len(dp))2. ブルーブリッジウォリアーズ
import sys #设置递归深度
import collections #队列
import itertools # 排列组合
import heapq #小顶堆
import math
sys.setrecursionlimit(300000)
n=int(input())
save=[0]+list(map(int,input().split()))
dp=[1]*(n+1) # 注意初始化从1开始
for i in range(2,n+1):
for j in range(1,i):
if save[i]>save[j]:
dp[i]=max(dp[i],dp[j]+1)
print(max(dp)) #最长公共子序列，dp[n]不一定是最大的
# 1 4 5 2 1
# 1 2 3 2 16.7 例 2 最長上昇サブシーケンス変形
import bisect # 内置二分查找
zifu = input()
A = [chr(65 + i) for i in range(26)]
s = ""
name = []
i = 0
zifu = zifu + "A" # 以后一个大写字符进行提取分隔
while i < len(zifu) - 1: # 提取数据格式为 name=[Wo,Ai,Lan,Qiao,Bei]
s += zifu[i]
if zifu[i + 1] in A:
name.append(s)
s = ""
i += 1
d = [name[0]]
p=[1] #存储下标
for i in name[1:]: # 遍历每一个字符
if i > d[-1]: # 大于，可以直接在后面接着
d.append(i) # 后面添加
p.append(len(d)) # 记录索引
else: # 查找第一个
k = bisect.bisect(d, i) # 使用bisect查找d中第一个大于等于i的元素,让其称为递增序列，有多个就是最右边的那个
if k > 0 and d[k - 1] == i: # 如果右索引的前一个数等于这个i的话，就将它替换掉，相等的不算递增？？？？
k -= 1
d[k] = i
p.append(k+1) # 记录替换的索引
p0=p[::-1] #逆序遍历输出
s=len(d) # 最长有多少个递增子序列
ans=""
for i in range(len(p0)): #逆序遍历
if s==0:
break
if p0[i]==s:
ans=name[len(p)-i-1]+ans #加上name
s=s-1
print(ans)