A：穿越时空之门
考察：字符串、枚举
Python算法
第十五届蓝桥杯 Python B 组省赛真题解析
详细解析第十五届蓝桥杯 Python B 组省赛八道试题。涉及字符串枚举、容斥原理、哈希表、时间处理、分类讨论、动态规划、图论缩点及贪心算法等知识点。提供各题解题思路、Python 代码实现及测试样例，帮助读者掌握竞赛解题技巧。
详细解析第十五届蓝桥杯 Python B 组省赛八道试题。涉及字符串枚举、容斥原理、哈希表、时间处理、分类讨论、动态规划、图论缩点及贪心算法等知识点。提供各题解题思路、Python 代码实现及测试样例，帮助读者掌握竞赛解题技巧。
考察：字符串、枚举
从 1 枚举到 2024，遇到符合条件的数就计数器加一，最后输出计数器即可。
ans = 0
def check(x):
# 判断是否符合条件
s1, s2 = sum(int(i) for i in bin(x)[2:]), 0
while x:
s2 += x % 4
x //= 4
return s1 == s2
for i in range(1, 2025):
ans += check(i)
print(ans) # 63
最后答案为：63
考察：容斥原理、快速幂取余
根据条件一：该数字串只能由数字 1 ~ 9 组成。
根据条件二：要减去不包含数字 3 或 7 的。用容斥原理做，集合总大小为：9^10000，减去两个 8^10000，由于多减了一个两个都不含的，再加上一个 7^10000。
快速幂取模可以用 Python 的内置函数 pow 实现。
mod = 10**9 + 7 # 157509472
print((pow(9, 10000, mod) - 2 * pow(8, 10000, mod) + pow(7, 10000, mod)) % mod)
最后答案为：157509472
考察：枚举、哈希表
由于要寻找横纵坐标差的绝对值相同的格子对的数量，所以有左上、右上、左下、右下四个方向。
如果使用枚举的方式来统计的话，时间复杂度是 O(n^3)，会超时，所以这里可以用一个哈希表来记录从左上到右下，或者从左下到右上方向的同一斜线方向上某个值出现的次数。然后由于同一斜向上每两个值相同，但位置不同的元素都能组成一对，所以用 c[x] 代表这一方向上 x 出现的个数，C(c[x])^2 就是格子对数。
然后再枚举不同斜线方向上的 c 并累加就行。
这里用一个函数来计算左上到右下方向上的，从左下到右上方向上的再把数组每一行逆序一下再计算就行了。
from collections import *
n, m = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(n)]
def acc(a):
# 统计从左上到右下方向上的格子对数量
res = 0
for k in range(-(n - 1), m):
i, j = -k * (k < 0), k * (k > 0)
# 该方向上第一个位置
c = Counter()
while i < n and j < m:
c[a[i][j]] += 1
i += 1
j += 1
for v in c.values():
res += v * (v - 1)
return res
print(acc(a) + acc([a[i][::-1] for i in range(n)]))
输入：
3 2
1 2
2 3
3 2
输出：
6
输入：
3 3
3 2 3
2 3 2
3 2 3
输出：
20
考察：时间处理
可以使用 Python 标准库中的 datetime 模块来解决此题。
本题中的输入是标准的 iso 格式日期时间，所以可以直接解析为 datetime 对象。
计算上一次响的时间：用总的分钟数减去对时间间隔求余的余数得到上次响的分钟数，再加上起始时间，转化为 datetime 对象，最后输出即可。
from datetime import *
bg = datetime.fromisoformat('1970-01-01 00:00:00')
for _ in range(int(input())):
date, time, dif = input().split()
dt = datetime.fromisoformat(date + ' ' + time)
nows = int((dt - bg).total_seconds()) // 60 # 分钟数
nows -= nows % int(dif)
print(bg + timedelta(minutes=nows))
输入：
2
2016-09-07 18:24:33 10
2037-01-05 01:40:43 30
输出：
2016-09-07 18:20:00
2037-01-05 01:30:00
考察：分类讨论、找规律
分别讨论一个村民的断言为假话、真话和后面的村民的断言为假话、真话的情况。再往后的村民的断言真假都可以通过前面的断言真假推断出来。
再往后就是之前的重复了。
注意上面前三个分支需要村民个数为 3 的倍数才行，这时'假'的个数为 2n；如果不为 3 的倍数，则只有最后一个情况符合条件，这时'假'的个数为 n。
for _ in range(int(input())):
n = int(input())
print(n * (1 + (not n % 3)))
考察：哈希表、DP
用两个哈希表 f1、f2 分别统计 s、t 序列中上一个包含 0、2、4 的符石作为序列末尾的最长序列长度。
注意要使用更新前的 f1 来更新 f2 和用更新前的 f2 更新 f1，所以需要对其中一个哈希表拷贝一下。
最后输出两个哈希表中的最大值即可。
cin = lambda: list(map(int, input().split()))
input()
f1, f2 = [-1] * 5, [-1] * 5
digs = (0, 2, 4)
def update(s, f1, f2):
for d in digs:
if str(d) in s:
f1[d] = max(f1[d], max(f2[i] + 1 for i in digs if str(i) in s))
for s, t in zip(cin(), cin()):
s, t = str(s), str(t)
f2_ = f2.copy() # 拷贝
update(t, f2, f1)
for d in digs:
if str(d) in s and f1[d] < 0:
f1[d] = max(*f1, 1) # 确保先从 s 开始走
update(s, f1, f2_)
print(max(f1 + f2))
输入：
5
126 393 581 42 44
204 990 240 46 52
输出：
4
输入：
5
10 42 44 42 22
24 40 52 42 44
输出：
5
考察：缩点、并查集、DFS
分析：由于要满足路径中最贵的一次收费在 [L, R] 区间内，所以收费大于 R 的路径是一定不可以经过的，而对于收费小于 L 的路径可以经过，但是不能让整条路径的收费全部小于 L，要不然路径的最大值也小于 L 了。
对此，我们要：将所有小于 L 的边连接的点缩成一个点（缩点），并记录缩后的点数（就是记录有多少个点缩成了这一个点），大于 R 的边则直接舍弃（不加到图中）。
然后再搜索满足条件的点对的数量，比如：有 3 个点缩成的点 A 和 2 个点缩成的点 B 之间有一条 [L, R] 之间的边，那么就有 2 x 3 = 6 个点对。示意图如下：
对应的点对分别为：(1, 4)、(1, 5)、(2, 4)、(2, 5)、(3, 4)、(3, 5)。
怎么实现缩点呢？并查集！将所有小于 L 的边连接的点用并查集来合并，让集合的根作为合并后的新点。注意记录集合的大小（也就是新点是由多少旧点合并来的）。
最后使用 DFS 累加点对数量（也可以用再用一个并查集找联通块）。比如点 A 是由 3 个旧点合并而来，与其连通的有 2 个新点，对应 5 个旧点，那么以 A 为第一个坐标的点对就有 3 x (8 - 3) 对。
注意累加的点对有重复（(1, 2)、(2, 1) 是同一对），最后要除以二。
from sys import *
setrecursionlimit(10**6)
cin = lambda: list(map(int, input().split()))
n, m, l, r = cin()
e = [set() for _ in range(n + 1)] # s[i] == i 表示 i 为新点，sz[i] 表示新点 i 的大小
s, sz = list(range(n + 1)), [1] * (n + 1)
def find(x):
if s[x] == x:
return x
s[x] = find(s[x])
return s[x]
edges = [cin() for _ in range(m)]
for u, v, w in edges:
if w > r:
continue # 舍弃
su, sv = find(u), find(v)
if w < l and su != sv: # 边权小于 l 且不在同一集合
# 合并
s[su] = sv
sz[sv] += sz[su] # 以新点建图
for u, v, w in edges:
if l <= w <= r:
su, sv = find(u), find(v)
e[su].add(sv)
e[sv].add(su)
vis = [False] * (n + 1)
def dfs(u, block):
# 寻找连通块，返回值表示该块内点的集合的总大小
block.append(u)
res, vis[u] = sz[u], True
for v in e[u]:
if vis[v]:
continue
res += dfs(v, block)
return res
ans = 0
for i in range(1, n + 1):
if s[i] == i and not vis[i]:
block = []
t = dfs(i, block)
for u in block:
ans += sz[u] * (t - sz[u])
print(ans // 2)
输入：
5 5 1 2
1 2 2
1 3 5
1 4 1
2 4 5
2 5 4
输出：
3
输入：
10 12 5 8
1 5 3
1 2 8
2 5 5
2 6 7
5 7 2
7 10 9
8 10 2
8 9 4
2 8 7
3 7 6
3 8 5
3 4 10
输出：
30
考察：贪心、思维
大概意思就是找一个数，能恰好组成 k 组（不冗余），且这个数尽可能大。
显然只有当每一组都选完还组不成 k 组的时候输出 -1，否则一定能组成 k 组。
如果能组成 k 组，那么设一个计数器 m = k 表示还缺几组没有凑够。
同职业中只有 1 ~ 2 个人的小队都加上，这不会增加组数。反之就每种职业都选出 3x + 2 个人，这样增加的小组数就是 x，如果凑够了，那么最终答案就是 ans - 2（为什么 - 2 呢，因为凑齐最后一组再加 1 就够了，而不是 3）如果后面发现没凑够 m 组，那就补上即可。
下面的代码直接用 k 来代替 m 了。
from collections import *
cin = lambda: list(map(int, input().split()))
for _ in range(int(input())):
n, k = cin()
cnt = Counter()
for i in range(n):
a, b = cin()
cnt[a] += b
if sum(c // 3 for c in cnt.values()) < k:
print(-1)
continue
ans, v = 0, list(cnt.values())
for i in range(len(v)):
if v[i] < 3:
ans += v[i]
v[i] = 0
continue
t = min((v[i] - 2) // 3, k)
v[i] -= t * 3 + 2
ans += t * 3 + 2
k -= t
if not k:
print(ans - 2)
continue
v.sort()
print(ans + sum(v[-k:]) - (v[-k] == 2))
输入：
2 3
2 1
3 2
3 3
3 3
5 1
3 2
3 3
输出：
8
-1
输入：
1 6
60 1
100 2
43 3
51 1
32 2
55 3
98
输出：
184
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。 在线工具，Markdown 转 HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML 转 Markdown在线工具，online