第一题

1.python的接收输入

import sys

line = sys.stdin.readline() # 假设输入"hello"后回车

print(repr(line)) # 输出: 'hello\n' (能看到\n)

循环读取接下来的n行，每一行是一个点的坐标 for _ in range(n): x, y = map(float, sys.stdin.readline().split())

2.十位数，个位数，十分位，百分位

个位：a = x%10

十位：b = (x//10)%10

十分位：c = int(x*10)%10

百分位：col = int(absZ * 100) % 10

3.最大共约数

def gcd(a, b):

while b:

a, b = b, a % b

return a

直接 import math

g = math.gca(a,b)

多个数的最大公约数：

4.二分查找

复制代码

def binary_search(nums, target):
    left, right = 0, len(nums)-1
    
    while left <= right:  # 包含等号
        mid = left + (right - left) // 2
        
        if nums[mid] == target:
            return mid
        elif nums[mid] < target:
            left = mid + 1  # 明确排除mid
        else:  # nums[mid] > target
            right = mid - 1  # 明确排除mid
    
    return -1

复制代码

while x < y:  # 当 x==y 时，只剩一个元素，就是峰值

第二题

def sliding_window_matrix_optimized(grid, k):

"""

计算 k*k 滑动窗口在矩阵上的和。

时间复杂度: O(m*n)

空间复杂度: O(m*n) (用于存储中间结果，可优化至 O(n))

"""

if not grid or not grid $0$ :

return \[\]

m, n = len(grid), len(grid $0$ )

if m < k or n < k:

return \[\]

Step 1: 计算每一行的水平滑动窗口和

horizontal_sums 的大小为 m x (n - k + 1)

horizontal_sums = $\[0$ * (n - k + 1) for _ in range(m)]

for i in range(m):

初始化当前行第一个窗口的和

current_sum = sum(grid $i$ $:k$ )

horizontal_sums $i$ $0$ = current_sum

滑动窗口：减去左边离开的，加上右边进入的

for j in range(1, n - k + 1):

current_sum = current_sum - grid $i$ $j - 1$ + grid $i$ $j + k - 1$

horizontal_sums $i$ $j$ = current_sum

Step 2: 在 horizontal_sums 的基础上，计算垂直滑动窗口和

result 的大小为 (m - k + 1) x (n - k + 1)

result = \[\]

只需要遍历列的宽度 (n - k + 1)

width = n - k + 1

for j in range(width):

提取这一列所有的水平和

col_data = $horizontal_sums\[i$ $j$ for i in range(m)]

初始化这一列第一个垂直窗口的和

current_col_sum = sum(col_data $:k$ )

col_result = $current_col_sum$

垂直滑动

for i in range(1, m - k + 1):

current_col_sum = current_col_sum - col_data $i - 1$ + col_data $i + k - 1$

col_result.append(current_col_sum)

将这一列的结果暂时存入，注意这里得到的是转置的结构，或者是列表的列表

这种写法为了代码清晰分了两步，实际为了 result 结构正确，通常会按行遍历

if j == 0:

result = $\[x$ for x in col_result]

else:

for i in range(len(col_result)):

result $i$ .append(col_result $i$ )

return result

def max_sliding_window(nums, k):

"""单调队列实现滑动窗口最大值"""

from collections import deque

n = len(nums)

if n * k == 0:

return \[\]

if k == 1:

return nums

def clean_deque(i):

移除不在窗口中的元素

if dq and dq $0$ == i - k:

dq.popleft()

移除小于当前元素的元素

while dq and nums $i$ > nums $dq\[-1$ ]:

dq.pop()

dq = deque()

max_idx = 0

for i in range(k):

clean_deque(i)

dq.append(i)

if nums $i$ > nums $max_idx$ :

max_idx = i

output = $nums\[max_idx$ ]

for i in range(k, n):

clean_deque(i)

dq.append(i)

output.append(nums $dq\[0$ ])

return output

2.递归公式构建

from functools import lru_cache

from typing import List

class RecursionTemplate:

"""递归+记忆化通用模板"""

def fibonacci(self, n: int) -> int:

"""斐波那契数列：f(n) = f(n-1) + f(n-2)"""

@lru_cache(None)

def dfs(x):

if x <= 1:

return x

return dfs(x-1) + dfs(x-2)

return dfs(n)

def combination_sum(self, nums: List $int$ , target: int) -> int:

"""组合求和：从nums中选取元素和为target的方案数"""

@lru_cache(None)

def dfs(remaining):

if remaining == 0:

return 1

if remaining < 0:

return 0

total = 0

for num in nums:

total += dfs(remaining - num)

return total

return dfs(target)

def dfs_with_params(self, grid: List $List\[int$ ]) -> int:

"""带参数的DFS模板"""

m, n = len(grid), len(grid $0$ )

directions = $(0, 1), (1, 0), (0, -1), (-1, 0)$

@lru_cache(None)

def dfs(x, y, visited_mask):

"""visited_mask可以用位运算表示访问状态"""

if x < 0 or x >= m or y < 0 or y >= n:

return 0

pos_mask = 1 << (x * n + y)

if visited_mask & pos_mask:

return 0

标记访问

new_mask = visited_mask | pos_mask

递归探索

best = 1 # 当前格子

for dx, dy in directions:

best = max(best, 1 + dfs(x+dx, y+dy, new_mask))

return best

return dfs(0, 0, 0)

3.分治

class DivideConquer:

"""分治算法模板"""

def merge_sort(self, nums: List $int$ ) -> List $int$ :

"""归并排序"""

if len(nums) <= 1:

return nums

mid = len(nums) // 2

left = self.merge_sort(nums $:mid$ )

right = self.merge_sort(nums $mid:$ )

return self._merge(left, right)

def _merge(self, left: List $int$ , right: List $int$ ) -> List $int$ :

result = \[\]

i = j = 0

while i < len(left) and j < len(right):

if left $i$ <= right $j$ :

result.append(left $i$ )

i += 1

else:

result.append(right $j$ )

j += 1

result.extend(left $i:$ )

result.extend(right $j:$ )

return result

def max_subarray(self, nums: List $int$ ) -> int:

"""最大子数组和（分治版本）"""

def divide_conquer(l, r):

if l == r:

return nums $l$

mid = (l + r) // 2

分治递归

left_max = divide_conquer(l, mid)

right_max = divide_conquer(mid + 1, r)

计算跨越中点的最大子数组和

从中点向左

left_cross = nums $mid$

curr = nums $mid$

for i in range(mid - 1, l - 1, -1):

curr += nums $i$

left_cross = max(left_cross, curr)

从中点向右

right_cross = nums $mid + 1$ if mid + 1 <= r else float('-inf')

curr = nums $mid + 1$ if mid + 1 <= r else 0

for i in range(mid + 2, r + 1):

curr += nums $i$

right_cross = max(right_cross, curr)

cross_max = left_cross + right_cross

return max(left_max, right_max, cross_max)

return divide_conquer(0, len(nums) - 1) if nums else 0

def closest_pair(self, points: List $List\[int$ ]) -> float:

"""最近点对问题"""

import math

def distance(p1, p2):

return math.sqrt((p1 $0$ - p2 $0$ )**2 + (p1 $1$ - p2 $1$ )**2)

def brute_force(pts):

min_dist = float('inf')

for i in range(len(pts)):

for j in range(i + 1, len(pts)):

min_dist = min(min_dist, distance(pts $i$ , pts $j$ ))

return min_dist

def strip_closest(strip, d):

min_dist = d

strip.sort(key=lambda p: p $1$ )

for i in range(len(strip)):

j = i + 1

只需检查y坐标差小于d的点

while j < len(strip) and (strip $j$ $1$ - strip $i$ $1$ ) < min_dist:

min_dist = min(min_dist, distance(strip $i$ , strip $j$ ))

j += 1

return min_dist

def divide_conquer(pts):

n = len(pts)

if n <= 3:

return brute_force(pts)

mid = n // 2

mid_point = pts $mid$

dl = divide_conquer(pts $:mid$ )

dr = divide_conquer(pts $mid:$ )

d = min(dl, dr)

检查跨越分割线的点对

strip = \[\]

for p in pts:

if abs(p $0$ - mid_point $0$ ) < d:

strip.append(p)

return min(d, strip_closest(strip, d))

points.sort(key=lambda p: p $0$ )

return divide_conquer(points)

4.最长回文子串

复制代码

class Solution:
    def longestPalindrome(self, s: str) -> str:
        def expand(l, r):
            while l >= 0 and r < len(s) and s[l] == s[r]:
                l -= 1
                r += 1
            return s[l + 1:r]
        
        res = ""
        for i in range(len(s)):
            # 奇数中心：i 是中心字符
            odd = expand(i, i)
            # 偶数中心：i 和 i+1 是中心两侧
            even = expand(i, i + 1)
            # 取最长
            res = max(res, odd, even, key=len)
        
        return res

复制代码

class Solution:
    def longestPalindrome(self, s: str) -> str:
        n = len(s)
        if n < 2:
            return s
        
        # dp[i][j] 表示 s[i:j+1] 是否是回文
        dp = [[False] * n for _ in range(n)]
        start = 0
        max_len = 1
        
        # 初始化：所有单个字符都是回文
        for i in range(n):
            dp[i][i] = True
        
        # 先枚举右边界 j
        for j in range(1, n):
            # 再枚举左边界 i (从 0 到 j-1)
            for i in range(j):
                # 核心判断：首尾字符是否相等
                if s[i] == s[j]:
                    # 如果子串长度 <= 3，一定是回文
                    if j - i < 3:
                        dp[i][j] = True
                    else:
                        # 否则取决于去掉首尾后的子串
                        dp[i][j] = dp[i + 1][j - 1]
                else:
                    dp[i][j] = False
                
                # 如果是回文且更长，更新结果
                if dp[i][j] and (j - i + 1) > max_len:
                    max_len = j - i + 1
                    start = i
        
        return s[start:start + max_len]

5.KMP算法

最短回文串

def shortestPalindrome_optimized(s: str) -> str:

"""优化版本，减少内存使用"""

if not s:

return ""

rev_s = s $::-1$

寻找s + "#" + rev_s的前缀函数

pattern = s + "#" + rev_s

只计算前缀函数

n = len(pattern)

next_arr = $0$ * n

for i in range(1, n):

j = next_arr $i - 1$

while j > 0 and pattern $i$ != pattern $j$ :

j = next_arr $j - 1$

if pattern $i$ == pattern $j$ :

j += 1

next_arr $i$ = j

最长回文前缀长度

palindrome_len = next_arr $-1$

需要添加的前缀

add_front = s $palindrome_len:$ $::-1$

return add_front + s

class KMP:

"""KMP算法完整模板"""

def build_next(self, pattern: str) -> List $int$ :

"""构建next数组（前缀函数）"""

n = len(pattern)

next_arr = $0$ * n

j = 0

for i in range(1, n):

while j > 0 and pattern $i$ != pattern $j$ :

j = next_arr $j - 1$

if pattern $i$ == pattern $j$ :

j += 1

next_arr $i$ = j

return next_arr

def search(self, text: str, pattern: str) -> List $int$ :

"""在text中搜索pattern的所有出现位置"""

if not pattern:

return $0$

next_arr = self.build_next(pattern)

m, n = len(text), len(pattern)

result = \[\]

j = 0

for i in range(m):

while j > 0 and text $i$ != pattern $j$ :

j = next_arr $j - 1$

if text $i$ == pattern $j$ :

j += 1

if j == n:

result.append(i - n + 1)

j = next_arr $j - 1$

return result

def repeated_substring_pattern(self, s: str) -> bool:

"""判断字符串是否由重复子串构成"""

n = len(s)

if n <= 1:

return False

next_arr = self.build_next(s)

如果存在重复子串，则n % (n - next_arr $-1$ ) == 0

return next_arr $-1$ != 0 and n % (n - next_arr $-1$ ) == 0

6.二叉树最近公共祖先

（包含节点不在树中的情况）

Definition for a binary tree node.

class TreeNode:

def init(self, x):

self.val = x

self.left = None

self.right = None

#哈希表法

class Solution:

def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':

if not root:

return None

parents = {root:None}

stack = $root$

while stack and (p not in parents or q not in parents):

node = stack.pop()

if node.left:

parents $node.left$ = node

stack.append(node.left)

if node.right:

parents $node.right$ = node

stack.append(node.right)

if p not in parents or q not in parents:

return None

ancestor = set()

while p:

ancestor.add(p)

p = parents $p$

while q not in ancestor:

q = parents $q$

return q

#递归法

复制代码

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        self.find_p = False
        self.find_q = False

        def f(root):
            if not root:
                return None

            left = f(root.left)
            right = f(root.right)

            if root==p:
                self.find_p=True
                return root
            if root==q:
                self.find_q=True
                return root


            if left and right:
                return root
            
            return left if left else right

        res = f(root)
        return res if self.find_p and self.find_q else None

深度优先搜索

class Solution:

def pathSum(self, root: Optional $TreeNode$ , targetSum: int) -> List $List\[int$ ]:

result = \[\]

path = \[\]

def dfs(node: Optional $TreeNode$ , target: int):

if not node: return

path.append(node.val)

if not node.left and not node.right:

if target == node.val:

result.append(path $:$ )

if node.left:

dfs(node.left, target - node.val)

if node.right:

dfs(node.right, target - node.val)

path.pop()

dfs(root, targetSum)

return result

第三题

1.队列/栈

from collections import deque

class StackQueueTemplates:

"""栈和队列常用模板"""

def monotonic_stack(self, nums: List $int$ ) -> List $int$ :

"""单调栈：下一个更大元素"""

n = len(nums)

result = $-1$ * n

stack = \[\] # 存储索引

for i in range(n):

while stack and nums $i$ > nums $stack\[-1$ ]:

idx = stack.pop()

result $idx$ = nums $i$

stack.append(i)

return result

def sliding_window_queue(self, nums: List $int$ , k: int) -> List $int$ :

"""单调队列实现滑动窗口最大值"""

n = len(nums)

if n == 0:

return \[\]

dq = deque()

result = \[\]

for i in range(n):

移除不在窗口中的元素

if dq and dq $0$ == i - k:

dq.popleft()

维护单调递减队列

while dq and nums $dq\[-1$ ] < nums $i$ :

dq.pop()

dq.append(i)

当窗口形成时记录结果

if i >= k - 1:

result.append(nums $dq\[0$ ])

return result

def daily_temperatures(self, temperatures: List $int$ ) -> List $int$ :

"""每日温度（下一个更高温度的天数）"""

n = len(temperatures)

result = $0$ * n

stack = \[\] # 存储(温度, 索引)

for i, temp in enumerate(temperatures):

while stack and temp > stack $-1$ $0$ :

_, idx = stack.pop()

result $idx$ = i - idx

stack.append((temp, i))

return result

2.树构建

中序遍历与后续遍历还原树

class Solution:

def buildTree(self, inorder: List $int$ , postorder: List $int$ ) -> Optional $TreeNode$ :

dic = {val:index for index,val in enumerate(inorder)}

def build(in_l,in_r,post_l,post_r):

if in_l>in_r or post_l>post_r:

return None

value = postorder $post_r$

index = dic $value$

length = index-in_l

root = TreeNode(value)

root.left = build(in_l,index-1,post_l,post_l+length-1)

root.right = build(index+1,in_r,post_l+length,post_r-1)

return root

return build(0,len(inorder)-1,0,len(inorder)-1)

3.散列/哈希表

class HashTemplates:

"""哈希表相关模板"""

def two_sum(self, nums: List $int$ , target: int) -> List $int$ :

"""两数之和"""

hashmap = {}

for i, num in enumerate(nums):

complement = target - num

if complement in hashmap:

return $hashmap\[complement$ , i]

hashmap $num$ = i

return \[\]

def subarray_sum(self, nums: List $int$ , k: int) -> int:

"""和为K的子数组个数"""

prefix_sum = 0

count = 0

hashmap = {0: 1} # 前缀和为0出现了1次

for num in nums:

prefix_sum += num

查找是否存在prefix_sum - k的前缀和

if prefix_sum - k in hashmap:

count += hashmap $prefix_sum - k$

更新当前前缀和的出现次数

hashmap $prefix_sum$ = hashmap.get(prefix_sum, 0) + 1

return count

def longest_consecutive(self, nums: List $int$ ) -> int:

"""最长连续序列"""

if not nums:

return 0

num_set = set(nums)

longest = 0

for num in num_set:

只从序列的起点开始计算

if num - 1 not in num_set:

current_num = num

current_streak = 1

while current_num + 1 in num_set:

current_num += 1

current_streak += 1

longest = max(longest, current_streak)

return longest

第四题

1.最短路径-树

import heapq

from typing import List, Tuple

class GraphShortestPath:

"""图的最短路径模板"""

def dijkstra(self, n: int, edges: List $List\[int$ ], start: int) -> List $int$ :

"""

Dijkstra算法 - 邻接表实现

edges: $\[u, v, w$ , ...] u->v权重w

"""

构建邻接表

graph = $\[$ for _ in range(n)]

for u, v, w in edges:

graph $u$ .append((v, w))

graph $v$ .append((u, w)) # 无向图

初始化距离数组

dist = $float('inf')$ * n

dist $start$ = 0

优先队列 (距离, 节点)

pq = $(0, start)$

while pq:

current_dist, u = heapq.heappop(pq)

如果当前距离大于记录的距离，跳过

if current_dist > dist $u$ :

continue

遍历邻居

for v, w in graph $u$ :

new_dist = current_dist + w

if new_dist < dist $v$ :

dist $v$ = new_dist

heapq.heappush(pq, (new_dist, v))

return dist

def floyd_warshall(self, n: int, edges: List $List\[int$ ]) -> List $List\[int$ ]:

"""Floyd-Warshall算法"""

初始化距离矩阵

dist = $\[float('inf')$ * n for _ in range(n)]

for i in range(n):

dist $i$ $i$ = 0

for u, v, w in edges:

dist $u$ $v$ = w

dist $v$ $u$ = w # 无向图

动态规划

for k in range(n):

for i in range(n):

for j in range(n):

if dist $i$ $k$ + dist $k$ $j$ < dist $i$ $j$ :

dist $i$ $j$ = dist $i$ $k$ + dist $k$ $j$

return dist

def kruskal_mst(self, n: int, edges: List $List\[int$ ]) -> List $List\[int$ ]:

"""Kruskal算法求最小生成树"""

按权重排序

edges.sort(key=lambda x: x $2$ )

parent = list(range(n))

def find(x):

if parent $x$ != x:

parent $x$ = find(parent $x$ )

return parent $x$

def union(x, y):

root_x = find(x)

root_y = find(y)

if root_x != root_y:

parent $root_x$ = root_y

return True

return False

mst = \[\]

total_weight = 0

for u, v, w in edges:

if union(u, v):

mst.append( $u, v, w$ )

total_weight += w

if len(mst) == n - 1:

break

return mst, total_weight

2.树上的公共节点

class TreeLCA:

"""树上最近公共祖先模板"""

def init(self, n: int, edges: List $List\[int$ ], root: int = 0):

self.n = n

self.log = (n).bit_length()

self.parent = $\[-1$ * n for _ in range(self.log)]

self.depth = $0$ * n

构建邻接表

self.adj = $\[$ for _ in range(n)]

for u, v in edges:

self.adj $u$ .append(v)

self.adj $v$ .append(u)

BFS初始化深度和父节点

stack = $root$

visited = $False$ * n

visited $root$ = True

while stack:

u = stack.pop()

for v in self.adj $u$ :

if not visited $v$ :

visited $v$ = True

self.parent $0$ $v$ = u

self.depth $v$ = self.depth $u$ + 1

stack.append(v)

倍增预处理

for k in range(1, self.log):

for v in range(n):

if self.parent $k-1$ $v$ != -1:

self.parent $k$ $v$ = self.parent $k-1$ $self.parent\[k-1$ $v$ ]

def lca(self, u: int, v: int) -> int:

"""查询u和v的最近公共祖先"""

if self.depth $u$ < self.depth $v$ :

u, v = v, u

将u提到和v同一深度

diff = self.depth $u$ - self.depth $v$

for k in range(self.log):

if diff & (1 << k):

u = self.parent $k$ $u$

if u == v:

return u

同时向上跳

for k in range(self.log - 1, -1, -1):

if self.parent $k$ $u$ != self.parent $k$ $v$ :

u = self.parent $k$ $u$

v = self.parent $k$ $v$

return self.parent $0$ $u$

def distance(self, u: int, v: int) -> int:

"""计算树上两点间距离"""

lca_node = self.lca(u, v)

return self.depth $u$ + self.depth $v$ - 2 * self.depth $lca_node$

Definition for a binary tree node.

class TreeNode:

def init(self, x):

self.val = x

self.left = None

self.right = None

class Solution:

def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':

if not root:

return None

parents = {root:None}

stack = $root$

while stack and (p not in parents or q not in parents):

node = stack.pop()

if node.left:

parents $node.left$ = node

stack.append(node.left)

if node.right:

parents $node.right$ = node

stack.append(node.right)

if p not in parents or q not in parents:

return None

ancestor = set()

while p:

ancestor.add(p)

p = parents $p$

while q not in ancestor:

q = parents $q$

return q

class Solution:

def lowestCommonAncestor(self, root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:

find_p = False

find_q = False

def f(root):

nonlocal find_p

nonlocal find_q

if not root:

return None

left = f(root.left)

right = f(root.right)

if root==p:

find_p = True

return root

if root==q:

find_q = True

return root

if left and right:

return root

return left if left else right

res = f(root)

return res if find_p and find_q else None

3.二分排序

class BinarySearch:

"""二分查找通用模板"""

def binary_search(self, nums: List $int$ , target: int) -> int:

"""标准二分查找"""

left, right = 0, len(nums) - 1

while left <= right:

mid = left + (right - left) // 2

if nums $mid$ == target:

return mid

elif nums $mid$ < target:

left = mid + 1

else:

right = mid - 1

return -1

def lower_bound(self, nums: List $int$ , target: int) -> int:

"""第一个大于等于target的位置"""

left, right = 0, len(nums)

while left < right:

mid = left + (right - left) // 2

if nums $mid$ >= target:

right = mid

else:

left = mid + 1

return left

def upper_bound(self, nums: List $int$ , target: int) -> int:

"""第一个大于target的位置"""

left, right = 0, len(nums)

while left < right:

mid = left + (right - left) // 2

if nums $mid$ > target:

right = mid

else:

left = mid + 1

return left

def search_range(self, nums: List $int$ , target: int) -> List $int$ :

"""在排序数组中查找元素的第一个和最后一个位置"""

start = self.lower_bound(nums, target)

if start == len(nums) or nums $start$ != target:

return $-1, -1$

end = self.upper_bound(nums, target) - 1

return $start, end$

def binary_search_answer(self, nums: List $int$ , k: int) -> int:

"""

二分答案模板

问题：将数组分成k个子数组，最小化最大子数组和

"""

def can_split(max_sum):

"""检查是否能在最大子数组和为max_sum的情况下分成k个子数组"""

current_sum = 0

count = 1

for num in nums:

if current_sum + num > max_sum:

count += 1

current_sum = num

if count > k:

return False

else:

current_sum += num

return True

left, right = max(nums), sum(nums)

while left < right:

mid = left + (right - left) // 2

if can_split(mid):

right = mid

else:

left = mid + 1

return left

4.容斥原理

class InclusionExclusion:

"""容斥原理模板"""

def count_divisible(self, n: int, divisors: List $int$ ) -> int:

"""

计算1到n中能被至少一个除数整除的数的个数

"""

m = len(divisors)

total = 0

遍历所有非空子集

for mask in range(1, 1 << m):

lcm_val = 1

bits = 0

for i in range(m):

if mask & (1 << i):

bits += 1

lcm_val = self.lcm(lcm_val, divisors $i$ )

if lcm_val > n: # 超过范围，可以提前终止

break

计算交集大小

count = n // lcm_val

根据子集大小添加或减去

if bits % 2 == 1:

total += count

else:

total -= count

return total

def lcm(self, a: int, b: int) -> int:

"""最小公倍数"""

return a * b // self.gcd(a, b)

def gcd(self, a: int, b: int) -> int:

"""最大公约数"""

while b:

a, b = b, a % b

return a

def count_coprime(self, n: int, m: int) -> int:

"""计算1到m中与n互质的数的个数（欧拉函数）"""

质因数分解

temp = n

primes = \[\]

p = 2

while p * p <= temp:

if temp % p == 0:

primes.append(p)

while temp % p == 0:

temp //= p

p += 1

if temp > 1:

primes.append(temp)

容斥原理计算

total = 0

k = len(primes)

for mask in range(1, 1 << k):

product = 1

bits = 0

for i in range(k):

if mask & (1 << i):

bits += 1

product *= primes $i$

count = m // product

if bits % 2 == 1:

total += count

else:

total -= count

return m - total

5.状态机DP

LeetCode1397. 找到所有好字符串，1931. 用三种颜色给网格涂色，1220. 统计元音字母序列

LeetCode123.买卖股票的最佳时机 III，714.买卖股票的最佳时机含手续费，309.最佳买卖股票时机含冷冻期，72.编辑距离

第五题

动态规划

1.背包问题（完全/不完全）

class Knapsack:

"""背包问题完整模板"""

def zero_one_knapsack(self, weights: List $int$ , values: List $int$ , capacity: int) -> int:

"""01背包问题"""

n = len(weights)

dp = $0$ * (capacity + 1)

for i in range(n):

逆向遍历，确保每个物品只选一次

for w in range(capacity, weights $i$ - 1, -1):

dp $w$ = max(dp $w$ , dp $w - weights\[i$ ] + values $i$ )

return dp $capacity$

def unbounded_knapsack(self, weights: List $int$ , values: List $int$ , capacity: int) -> int:

"""完全背包问题"""

n = len(weights)

dp = $0$ * (capacity + 1)

for i in range(n):

正向遍历，允许重复选择

for w in range(weights $i$ , capacity + 1):

dp $w$ = max(dp $w$ , dp $w - weights\[i$ ] + values $i$ )

return dp $capacity$

def multi_knapsack(self, weights: List $int$ , values: List $int$ , counts: List $int$ , capacity: int) -> int:

"""多重背包问题（二进制优化）"""

n = len(weights)

二进制拆分

new_weights = \[\]

new_values = \[\]

for i in range(n):

k = 1

remaining = counts $i$

while remaining >= k:

new_weights.append(weights $i$ * k)

new_values.append(values $i$ * k)

remaining -= k

k <<= 1

if remaining > 0:

new_weights.append(weights $i$ * remaining)

new_values.append(values $i$ * remaining)

01背包

return self.zero_one_knapsack(new_weights, new_values, capacity)

def knapsack_scheme(self, weights: List $int$ , values: List $int$ , capacity: int) -> List $int$ :

"""输出具体方案"""

n = len(weights)

dp = $\[0$ * (capacity + 1) for _ in range(n + 1)]

for i in range(1, n + 1):

for w in range(capacity + 1):

if weights $i-1$ <= w:

dp $i$ $w$ = max(dp $i-1$ $w$ , dp $i-1$ $w - weights\[i-1$ ] + values $i-1$ )

else:

dp $i$ $w$ = dp $i-1$ $w$

回溯找方案

res = \[\]

w = capacity

for i in range(n, 0, -1):

if dp $i$ $w$ != dp $i-1$ $w$ :

res.append(i-1)

w -= weights $i-1$

return res $::-1$ # 返回选择的物品索引

编辑距离

2.反悔贪心

LeetCode 630

import heapq

class RegretGreedy:

"""反悔贪心模板"""

def schedule_course(self, courses: List $List\[int$ ]) -> int:

"""

课程安排III：选择最多的课程

courses $i$ = $duration, lastDay$

"""

按截止时间排序

courses.sort(key=lambda x: x $1$ )

max_heap = \[\] # 最大堆，存储已选课程的持续时间

current_time = 0

for duration, last_day in courses:

if current_time + duration <= last_day:

heapq.heappush(max_heap, -duration)

current_time += duration

elif max_heap and -max_heap $0$ > duration:

反悔：替换掉持续时间最长的课程

longest = -heapq.heappop(max_heap)

current_time = current_time - longest + duration

heapq.heappush(max_heap, -duration)

return len(max_heap)

def max_profit_jobs(self, startTime: List $int$ , endTime: List $int$ , profit: List $int$ ) -> int:

"""最大收益工作安排"""

jobs = sorted(zip(startTime, endTime, profit), key=lambda x: x $1$ )

n = len(jobs)

dp = $0$ * (n + 1)

for i in range(1, n + 1):

s, e, p = jobs $i-1$

找到结束时间不超过s的最后一个工作

j = i - 1

while j >= 1 and jobs $j-1$ $1$ > s:

j -= 1

选择当前工作或不选

dp $i$ = max(dp $i-1$ , dp $j$ + p)

return dp $n$

3.最大堆

class HeapTemplates:

"""堆操作模板"""

def median_finder(self):

"""数据流的中位数（双堆法）"""

import heapq

class MedianFinder:

def init(self):

self.small = \[\] # 最大堆（用负数实现）

self.large = \[\] # 最小堆

def addNum(self, num: int) -> None:

if len(self.small) == len(self.large):

heapq.heappush(self.large, -heapq.heappushpop(self.small, -num))

else:

heapq.heappush(self.small, -heapq.heappushpop(self.large, num))

def findMedian(self) -> float:

if len(self.small) == len(self.large):

return (-self.small $0$ + self.large $0$ ) / 2

else:

return self.large $0$

return MedianFinder()

def kth_largest(self, nums: List $int$ , k: int) -> int:

"""第K大的元素"""

import heapq

min_heap = \[\]

for num in nums:

heapq.heappush(min_heap, num)

if len(min_heap) > k:

heapq.heappop(min_heap)

return min_heap $0$ if min_heap else -1

def merge_k_sorted(self, lists: List $List\[int$ ]) -> List $int$ :

"""合并K个有序链表/数组"""

import heapq

heap = \[\]

初始化堆，存储(值, 列表索引, 元素索引)

for i, lst in enumerate(lists):

if lst:

heapq.heappush(heap, (lst $0$ , i, 0))

result = \[\]

while heap:

val, list_idx, elem_idx = heapq.heappop(heap)

result.append(val)

如果当前列表还有下一个元素

if elem_idx + 1 < len(lists $list_idx$ ):

next_val = lists $list_idx$ $elem_idx + 1$

heapq.heappush(heap, (next_val, list_idx, elem_idx + 1))

return result

4.如何找树的割点

class ArticulationPoints:

"""寻找无向图的割点（Tarjan算法）"""

def find_cut_points(self, n: int, edges: List $List\[int$ ]) -> List $int$ :

"""

寻找图中的所有割点

割点：移除该点后，图的连通分量数增加

"""

构建邻接表

graph = $\[$ for _ in range(n)]

for u, v in edges:

graph $u$ .append(v)

graph $v$ .append(u)

visited = $False$ * n

disc = $0$ * n # 发现时间

low = $0$ * n # 可回溯到的最早发现时间

parent = $-1$ * n

time = 0

articulation = $False$ * n

def dfs(u):

nonlocal time

children = 0

visited $u$ = True

disc $u$ = low $u$ = time

time += 1

for v in graph $u$ :

if not visited $v$ :

children += 1

parent $v$ = u

dfs(v)

更新low值

low $u$ = min(low $u$ , low $v$ )

判断是否为割点

1. 根节点且有两个以上子节点

if parent $u$ == -1 and children > 1:

articulation $u$ = True

2. 非根节点且low $v$ >= disc $u$

if parent $u$ != -1 and low $v$ >= disc $u$ :

articulation $u$ = True

elif v != parent $u$ : # 回退边

low $u$ = min(low $u$ , disc $v$ )

for i in range(n):

if not visited $i$ :

dfs(i)

return $i for i in range(n) if articulation\[i$ ]

5.树删除节点后如何划分

树上子树区间（Euler 序）与前缀和

class TreeSubtree:

"""子树统计与划分"""

def init(self, n: int, edges: List $List\[int$ ]):

self.n = n

self.adj = $\[$ for _ in range(n)]

for u, v in edges:

self.adj $u$ .append(v)

self.adj $v$ .append(u)

欧拉序

self.euler_in = $0$ * n

self.euler_out = $0$ * n

self.euler_path = \[\]

self.time = 0

self.dfs_euler(0, -1)

子树大小

self.subtree_size = $0$ * n

self.dfs_size(0, -1)

def dfs_euler(self, u: int, parent: int):

"""DFS求欧拉序"""

self.euler_in $u$ = self.time

self.euler_path.append(u)

self.time += 1

for v in self.adj $u$ :

if v != parent:

self.dfs_euler(v, u)

self.euler_out $u$ = self.time - 1

def dfs_size(self, u: int, parent: int) -> int:

"""计算子树大小"""

size = 1

for v in self.adj $u$ :

if v != parent:

size += self.dfs_size(v, u)

self.subtree_size $u$ = size

return size

def is_ancestor(self, u: int, v: int) -> bool:

"""判断u是否是v的祖先（欧拉序）"""

return self.euler_in $u$ <= self.euler_in $v$ <= self.euler_out $u$

def subtree_range(self, u: int) -> Tuple $int, int$ :

"""返回节点u的子树在欧拉序中的范围"""

return (self.euler_in $u$ , self.euler_out $u$ )

def remove_node_partition(self, u: int) -> List $int$ :

"""

删除节点u后，划分成的各个连通块的大小

注意：删除节点后，除了子树外，还有父节点所在的连通块

"""

sizes = \[\]

父节点所在的连通块大小

parent_component = self.n - self.subtree_size $u$

if parent_component > 0:

sizes.append(parent_component)

每个子节点的子树大小

for v in self.adj $u$ :

if self.is_ancestor(v, u): # v是u的子节点

sizes.append(self.subtree_size $v$ )

return sizes

def find_centroid(self) -> List $int$ :

"""寻找树的重心（删除后最大子树最小的节点）"""

centroids = \[\]

min_max_subtree = self.n

def dfs_centroid(u: int, parent: int):

nonlocal min_max_subtree, centroids

max_subtree = 0

total = 1

for v in self.adj $u$ :

if v != parent:

dfs_centroid(v, u)

subtree_size = self.subtree_size $v$

max_subtree = max(max_subtree, subtree_size)

total += subtree_size

父节点所在的连通块

parent_subtree = self.n - total

max_subtree = max(max_subtree, parent_subtree)

if max_subtree < min_max_subtree:

min_max_subtree = max_subtree

centroids = $u$

elif max_subtree == min_max_subtree:

centroids.append(u)

return total

dfs_centroid(0, -1)

return centroids

6.动态树/查询子树

class DynamicTree:

"""支持子树更新的动态树"""

def init(self, n: int, values: List $int$ , edges: List $List\[int$ ]):

self.n = n

self.values = values

构建邻接表

self.adj = $\[$ for _ in range(n)]

for u, v in edges:

self.adj $u$ .append(v)

self.adj $v$ .append(u)

欧拉序

self.in_time = $0$ * n

self.out_time = $0$ * n

self.euler = \[\]

self.time = 0

self.dfs_euler(0, -1)

树状数组（Fenwick Tree）

self.bit = $0$ * (n + 2)

初始化树状数组

for i, node in enumerate(self.euler):

self._add(i + 1, self.values $node$ )

def dfs_euler(self, u: int, parent: int):

"""DFS求欧拉序"""

self.in_time $u$ = self.time

self.euler.append(u)

self.time += 1

for v in self.adj $u$ :

if v != parent:

self.dfs_euler(v, u)

self.out_time $u$ = self.time - 1

def _add(self, idx: int, delta: int):

"""树状数组更新"""

while idx <= self.n:

self.bit $idx$ += delta

idx += idx & -idx

def _sum(self, idx: int) -> int:

"""树状数组前缀和"""

res = 0

while idx > 0:

res += self.bit $idx$

idx -= idx & -idx

return res

def update_subtree(self, u: int, delta: int):

"""更新节点u的整个子树"""

l = self.in_time $u$ + 1 # 树状数组从1开始

r = self.out_time $u$ + 1

self._add(l, delta)

if r + 1 <= self.n:

self._add(r + 1, -delta)

def query_subtree(self, u: int) -> int:

"""查询节点u的子树和"""

idx = self.in_time $u$ + 1

return self._sum(idx)

def update_node(self, u: int, new_val: int):

"""更新单个节点的值"""

old_val = self.values $u$

delta = new_val - old_val

self.values $u$ = new_val

self.update_subtree(u, delta)

def query_path(self, u: int, v: int) -> int:

"""查询u到v路径上的和（需要LCA）"""

实现路径查询需要LCA，这里给出简化版本

实际应用中可能需要树链剖分

pass

一些细节问题

1.count = defaultdict(int)指定默认值类型

class Utils:

"""常用工具函数"""

@staticmethod

def quick_sort(nums: List $int$ ) -> List $int$ :

"""快速排序"""

if len(nums) <= 1:

return nums

pivot = nums $len(nums) // 2$

left = $x for x in nums if x \< pivot$

middle = $x for x in nums if x == pivot$

right = $x for x in nums if x \> pivot$

return Utils.quick_sort(left) + middle + Utils.quick_sort(right)

@staticmethod

def union_find(n: int):

"""并查集模板"""

parent = list(range(n))

size = $1$ * n

def find(x: int) -> int:

if parent $x$ != x:

parent $x$ = find(parent $x$ )

return parent $x$

def union(x: int, y: int) -> bool:

root_x = find(x)

root_y = find(y)

if root_x == root_y:

return False

按秩合并

if size $root_x$ < size $root_y$ :

root_x, root_y = root_y, root_x

parent $root_y$ = root_x

size $root_x$ += size $root_y$

return True

def connected(x: int, y: int) -> bool:

return find(x) == find(y)

return find, union, connected

@staticmethod

def topological_sort(n: int, edges: List $List\[int$ ]) -> List $int$ :

"""拓扑排序"""

from collections import deque

graph = $\[$ for _ in range(n)]

indegree = $0$ * n

for u, v in edges:

graph $u$ .append(v)

indegree $v$ += 1

queue = deque( $i for i in range(n) if indegree\[i$ == 0])

result = \[\]

while queue:

u = queue.popleft()

result.append(u)

for v in graph $u$ :

indegree $v$ -= 1

if indegree $v$ == 0:

queue.append(v)

return result if len(result) == n else \[\] # 有环则返回空

CSP认证 备考（python)

第一题

1.python的接收输入

循环读取接下来的n行，每一行是一个点的坐标 for _ in range(n): x, y = map(float, sys.stdin.readline().split())

2.十位数，个位数，十分位，百分位

3.最大共约数

4.二分查找

第二题

Step 1: 计算每一行的水平滑动窗口和

horizontal_sums 的大小为 m x (n - k + 1)

初始化当前行第一个窗口的和

滑动窗口：减去左边离开的，加上右边进入的

Step 2: 在 horizontal_sums 的基础上，计算垂直滑动窗口和

result 的大小为 (m - k + 1) x (n - k + 1)

只需要遍历列的宽度 (n - k + 1)

提取这一列所有的水平和

初始化这一列第一个垂直窗口的和

垂直滑动

将这一列的结果暂时存入，注意这里得到的是转置的结构，或者是列表的列表

这种写法为了代码清晰分了两步，实际为了 result 结构正确，通常会按行遍历

移除不在窗口中的元素

移除小于当前元素的元素

2.递归公式构建

标记访问

递归探索

3.分治

分治递归

计算跨越中点的最大子数组和

从中点向左

从中点向右

只需检查y坐标差小于d的点

检查跨越分割线的点对

4.最长回文子串

5.KMP算法

寻找s + "#" + rev_s的前缀函数

只计算前缀函数

最长回文前缀长度

需要添加的前缀

如果存在重复子串，则n % (n - next_arr-1) == 0

6.二叉树最近公共祖先

Definition for a binary tree node.

class TreeNode:

def init(self, x):

self.val = x

self.left = None

self.right = None

深度优先搜索

第三题

1.队列/栈

移除不在窗口中的元素

维护单调递减队列

当窗口形成时记录结果

2.树构建

3.散列/哈希表

查找是否存在prefix_sum - k的前缀和

更新当前前缀和的出现次数

只从序列的起点开始计算

第四题

1.最短路径-树

构建邻接表

初始化距离数组

优先队列 (距离, 节点)

如果当前距离大于记录的距离，跳过

遍历邻居

初始化距离矩阵

动态规划

按权重排序

2.树上的公共节点

构建邻接表

BFS初始化深度和父节点

倍增预处理

将u提到和v同一深度

同时向上跳

Definition for a binary tree node.

class TreeNode:

def init(self, x):

self.val = x

self.left = None

self.right = None

3.二分排序

CSP认证备考（python)

如果存在重复子串，则n % (n - next_arr $-1$ ) == 0

2. 非根节点且low $v$ >= disc $u$