分享｜算法竞赛中 Python 的优化技巧

import sys
input = lambda: sys.stdin.readline().rstrip()  # 需要删除行末换行符
II = lambda: int(input())
LII = lambda: list(map(int, input().split()))

import sys
# 输入仅包含整数
it = map(int, sys.stdin.read().split())
II = lambda: next(it)
# 输入包含字符串
it = iter(sys.stdin.read().split())
SI = lambda: next(it)
II = lambda: int(SI())

output = []
for _ in range(n):
    ans = solve()
    output.append(ans)
print(*output, sep='\n')

def add(x, y): return (x + y) % MOD
def sub(x, y): return (x - y) % MOD

def add(x, y):
    x += y
    if x >= MOD: x -= MOD
    return x
def sub(x, y):
    x -= y
    if x < 0: x += MOD
    return x

ans = 0
for i in range(n):
    ans = (ans + comb(n, i) * pow(2, i, MOD) % MOD) % MOD

ans = 0
for i in range(n):
    ans += comb(n, i) * pow(2, i, MOD)
ans %= MOD

t = list(s)
t[0] = 'a'
s = ''.join(t)

t = bytearray(s, encoding='ascii')
t[0] = ord('a')
s = t.decode('ascii')

for i in range(len(nums)):
    x = nums[i]
    ...
for i in range(len(nums) - 1, -1, -1):
    x = nums[i]
    ...
for i in range(len(a)):
    x, y = a[i], b[i]
    ...

for i, x in enumerate(nums):
    ...
for x in reversed(nums):
    ...
for x, y in zip(a, b):
    ...

nums = []
for _ in range(n):
    nums.append(x)

nums = [0] * n
for i in range(n):
    nums[i] = x

n, k = 10**5, 20
dp = [[0] * k for _ in range(n)]

n, k = 10**5, 20
dp = [[0] * n for _ in range(k)]

dp = [[0] * n for _ in range(m)]

dp = [0] * (m*n)
compress = lambda i, j: i*n+j
decompress = lambda k: divmod(k, n)

s = sum(nums[i] for i in range(l, r))
mx = 0
for i in range(l, r): mx = max(mx, nums[i])

s = sum(nums[l:r])
mx = max(nums[l:r])

nums = [0] * n

from array import array
nums = array('i', [0] * n)

vis = [False] * n

vis = bytearray(bytes(n))

rank = [0] * n
pa = list(range(n))

from ctypes import c_int32
rank = (c_int32 * n)()
pa = (c_int32 * n)(*range(n))

items = [(w1, v1), (w2, v2), ...]

weights = [w1, w2, ...]
values = [v1, v2, ...]

g = defaultdict(list)

g = [[] for _ in range(n)]

for k in mp:
    v = mp[k]
    ...

for k, v in mp.items():
    ...

mp = defaultdict(int)
x = mp[k]

mp = defaultdict(int)
x = mp.get(k, 0)

mx = 0
for x in nums:
    if x > mx: mx = x

mx = max(nums)

s = sum(x for x in nums if x & 1)

s = 0
for x in nums:
    if x & 1:
        s += x

x, y = min(x, y), max(x, y)

fmin = lambda x, y: x if x < y else y
fmax = lambda x, y: x if x > y else y
x, y = fmin(x, y), fmax(x, y)

MOD = 10**9+7
inv = pow(x, -1, MOD)

MOD = 10**9+7
def qpow(x, k):
    res = 1
    while k:
        if k & 1:
            res = res * x % MOD
        x = x * x % MOD
        k >>= 1
    return res
inv = qpow(x, MOD-2)

@cache
def dp(i: int, pre: int, islim: bool, isnum: bool) -> int:
    ...

memo = [[-1] * 10 for _ in range(n)]
def dp(i: int, pre: int, islim: bool, isnum: bool) -> int:
    if not islim and not isnum and memo[i][pre] != -1:
        return memo[i][pre]
    ...

def all_subsets(mask):
    subs = []
    cur = mask
    while cur:
        subs.append(cur)
        cur = (cur - 1) & mask
    return subs

def all_subsets(mask):
    cur = mask
    while cur:
        yield cur
        cur = (cur - 1) & mask

s = sum([x**2 for x in range(n)])

s = sum(x**2 for x in range(n))

def main():
    ...
main()

class DSU:
    def __init__(self, n: int):
        self.parent = list(range(n))
        self.size = [1] * n

class DSU:
    __slots__ = 'parent', 'size'
    def __init__(self, n: int):
        self.parent = list(range(n))
        self.size = [1] * n

class DSU:
    def find(self, u: int):
        while u != self.parent[u]:
            u = self.parent[u]
        return u

class DSU:
    def find(self, u: int):
        parent = self.parent
        while u != parent[u]:
            u = parent[u]
        return u

class TrieNode:
    def __init__(self):
        self.children = [None] * 26
        self.isend = False
        self.cnt = 0
class Trie:
    def __init__(self):
        self.root = TrieNode()
    ...

class StaticTrie:
    def __init__(self, lengths):
        lengths += 1
        self.children = [[-1] * lengths for _ in range(26)]
        self.isend = [False] * lengths
        self.cnt = [0] * lengths
        self.ptr = 1
    ...

order = []
def dfs(u: int, pa: int):
    order.append(u)
    for v in tree[u]:
        if v != pa:
            dfs(v, u)

order = []
parents = [-1] * len(tree)
stk = [root]
while stk:
    u = stk.pop()
    order.append(u)
    for v in g[u]:
        if parents[u] != v:
            parents[v] = u
            stk.append(v)

g = [[] for _ in range(n)]
def add_edge(u: int, v: int, w: int):
    g[u].append((v, w))

head = [-1] * n
to = [-1] * m
weight = [0] * m
nxt = [-1] * m
ptr = 0
def add_edge(u: int, v: int, w: int):
    nonlocal ptr
    to[ptr] = v
    weight[ptr] = w
    nxt[ptr] = head[u]
    head[u] = ptr
    ptr += 1