目录
A：穿越时空之门 100🏆
随着 2024 年的钟声回荡，传说中的时空之门再次敞开。这扇门是一条神秘的通道，它连接着二进制和四进制两个不同的数码领域，等待着勇者们的探索。
在二进制的领域里，勇者的力量被转换成了力量数值的二进制表示中各数位之和。
在四进制的领域里，力量的转换规则相似，变成了力量数值的四进制表示中各数位之和。
穿越这扇时空之门的条件是严苛的：当且仅当勇者在二进制领域的力量等同于四进制领域的力量时，他才能够成功地穿越。
国王选定了小蓝作为领路人，带领着力量值从 1 到 2024 的勇者们踏上了这段探索未知的旅程。作为小蓝的助手，你的任务是帮助小蓝计算出，在这 2024 位勇者中，有多少人符合穿越时空之门的条件。
def er(x):
s=0
while x:
s+=x%2
x//=2
return s
def si(x):
s=0
while x:
s+=x%4
x//=4
return s
cnt=0
for i in range(1,2025):
if er(i)==si(i):
cnt+=1
print(cnt)
# 答案：63B：数字串个数 0🏆
小蓝想要构造出一个长度为 10000 的数字字符串，有以下要求：
1) 小蓝不喜欢数字 0 ，所以数字字符串中不可以出现 0 ；
2) 小蓝喜欢数字 3 和 7 ，所以数字字符串中必须要有 3 和 7 这两个数字。
请问满足题意的数字字符串有多少个？这个数字会很大，你只需要输出其 对 取余后的结果。
补题：容斥原理
mod = int(1e9 + 7)
n = 10000
cnt = pow(9, n, mod)
# 去除 no(3) + no(7) 的情况
cnt -= 2 * pow(8, n, mod)
# 补上 no(3 and 7) 的情况
cnt += pow(7, n, mod)
print(cnt % mod)C：连连看 45🏆
时间限制: 3s 内存限制: 512MB 提交: 408 解决: 45
题目描述
小蓝正在和朋友们玩一种新的连连看游戏。在一个 n × m 的矩形网格中，每个格子中都有一个整数，第 i 行第 j 列上的整数为 Ai, j 。玩家需要在这个网格中寻找一对格子 (a, b) − (c, d) 使得这两个格子中的整数 Aa,b 和 Ac,d 相等，且它们的位置满足 |a − c| = |b − d| > 0 。请问在这个 n × m 的矩形网格中有多少对这样的格子满足条件。
输入格式
输入的第一行包含两个正整数 n, m ，用一个空格分隔。
接下来 n 行，第 i 行包含 m 个正整数 Ai,1, Ai,2, · · · , Ai,m ，相邻整数之间使用一个空格分隔。
输出格式
输出一行包含一个整数表示答案。
样例输入
3 2 1 2 2 3 3 2
样例输出
6
提示
【样例说明】
一共有以下 6 对格子：(1, 2) − (2, 1) ，(2, 2) − (3, 1) ，(2, 1) − (3, 2) ，(2, 1) −(1, 2) ，(3, 1) − (2, 2) ，(3, 2) − (2, 1) 。
【评测用例规模与约定】
对于 20% 的评测用例，1 ≤ n, m ≤ 50 ；对于所有评测用例，1 ≤ n, m ≤ 1000 ，1 ≤ Ai, j ≤ 1000 。
暴力：
n,m=map(int,input().split())
dic=dict()
for i in range(1,n+1):
a=list(map(int,input().split()))
for j in range(m):
if a[j] not in dic:
dic[a[j]]=[(i,j+1)]
else:
dic[a[j]].append((i,j+1))
cnt=0
for i in dic:
for j in range(len(dic[i])):
for k in range(len(dic[i])):
if j!=k and abs(dic[i][j][0]-dic[i][k][0])==abs(dic[i][j][1]-dic[i][k][1]):
cnt+=1
print(cnt)
D：神奇闹钟 9🏆
时间限制: 3s 内存限制: 512MB 提交: 283 解决: 111
题目描述
小蓝发现了一个神奇的闹钟，从纪元时间（1970 年 1 月 1 日 00:00:00 ）开始，每经过 x 分钟，这个闹钟便会触发一次闹铃（纪元时间也会响铃）。这引起了小蓝的兴趣，他想要好好研究下这个闹钟。
对于给出的任意一个格式为 yyyy-MM-dd HH:mm:ss 的时间，小蓝想要知道在这个时间点之前（包含这个时间点）的最近的一次闹铃时间是哪个时间？
注意，你不必考虑时区问题。
输入格式
输入的第一行包含一个整数 T，表示每次输入包含 T 组数据。
接下来依次描述 T 组数据。
每组数据一行，包含一个时间（格式为 yyyy-MM-dd HH:mm:ss ）和一个整数 x ，其中 x 表示闹铃时间间隔（单位为分钟）。
输出格式
输出 T 行，每行包含一个时间（格式为 yyyy-MM-dd HH:mm:ss ），依次表示每组数据的答案。
样例输入
复制
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
提示
【评测用例规模与约定】
对于所有评测用例，1 ≤ T ≤ 10，1 ≤ x ≤ 1000，保证所有的时间格式都是合法的。
补题：
import time
fmt = "%Y-%m-%d %H:%M:%S"
for _ in range(int(input())):
datetime, x = input().rsplit(maxsplit=1)
x = int(x) * 60
t = round(time.mktime(time.strptime(datetime, fmt)))
print(time.strftime(fmt, time.localtime(t - t % x)))
```
import time：导入Python的time模块，该模块提供了各种与时间相关的函数。
fmt = "%Y-%m-%d %H:%M:%S"：定义一个格式化字符串，用于表示时间的格式，其中%Y是4位年份，%m是月份，%d是日期，%H是小时（24小时制），%M是分钟，%S是秒。
for _ in range(int(input())):：这将重复执行代码块，次数由用户输入的整数决定。
datetime, x = input().rsplit(maxsplit=1)：读取用户的输入，使用rsplit以最后一个空格为分隔符将输入分割成两部分，datetime是时间字符串，x是用户希望对齐到的分钟数（以字符串形式输入）。
x = int(x) * 60：将输入的分钟数转换为秒数，因为time.mktime()函数需要秒数作为输入。
t = round(time.mktime(time.strptime(datetime, fmt)))：使用time.strptime()将时间字符串转换为时间元组，然后使用time.mktime()将时间元组转换为自纪元以来的秒数（纪元即UNIX时间的开始，1970年1月1日）。round()函数确保结果为最接近的整数。
print(time.strftime(fmt, time.localtime(t - t % x)))：首先计算当前时间距离输入时间的最近整点（或指定分钟数）的秒数，通过取余操作t % x得到当前时间与最近整点的差值，然后从t中减去这个差值。time.localtime()将秒数转换回时间元组，time.strftime()将时间元组格式化为指定的字符串格式。
```E：蓝桥村的真相 18🏆
时间限制: 3s 内存限制: 512MB 提交: 349 解决: 41
题目描述
在风景如画的蓝桥村，n 名村民围坐在一张古老的圆桌旁，参与一场思想的较量。这些村民，每一位都有着鲜明的身份：要么是誉满乡野的诚实者，要么是无可救药的说谎者。当会议的钟声敲响，一场关于真理与谬误的辩论随之展开。每位村民轮流发言，编号为 i 的村民提出了这样的断言：坐在他之后的两位村民——也就是编号 i + 1 和 i + 2（注意，编号是环形的，所以如果 i 是最后一个，则 i + 1 是第一个，以此类推）之中，一个说的是真话，而另一个说的是假话。在所有摇曳不定的陈述中，有多少真言隐藏在谎言的面纱之后？
请你探索每一种可能的真假排列组合，并计算在所有可能的真假组合中，说谎者的总数。
输入格式
输入的第一行包含一个整数 T，表示每次输入包含 T 组数据。
接下来依次描述 T 组数据。
每个数据一行包含一个整数 n，表示村落的人数。
输出格式
输出 T 行，每行包含一个整数，依次表示每组数据的答案。
样例输入
复制
2 3 3
样例输出
复制
6 6
提示
【样例说明】
在样例中，可能的组合有「假，假，假」「真，真，假」「真，假，真」「假，真，真」，说谎者的总数为 3 + 1 + 1 + 1 = 6。
【评测用例规模与约定】
对于 10% 的评测用例，T = 1，3 ≤ n ≤ 10。
对于 40% 的评测用例，1 ≤ T ≤ 102，3 ≤ n ≤ 3 × 103。
对于所有评测用例，1 ≤ T ≤ 105，3 ≤ n ≤ 1018。
for _ in range(int(input())):
n = int(input())
print(n * (1 + (n % 3 == 0)))F：魔法巡游 100🏆
时间限制: 3s 内存限制: 512MB 提交: 150 解决: 12
题目描述
在蓝桥王国中，两位魔法使者，小蓝与小桥，肩负着维护时空秩序的使命。他们每人分别持有 N 个符文石，这些石头被赋予了强大的力量，每一块上都刻有一个介于 1 到 109 之间的数字符号。小蓝的符文石集合标记为 s1, s2, . . . , sN，小桥的则为 t1, t2, . . . , tN。
两位魔法使者的任务是通过使用符文石，在各个时空结点间巡游。每次巡游遵循这样一条法则：当小蓝使用了符文石 si 到达新的结点后，小桥必须选用一个序号更大的符文石（即某个 tj 满足 j > i）前往下一个结点。同理，小桥抵达之后，小蓝需要选择一个序号 k > j 的符文石 sk 继续他们的巡游。为了成功地穿梭时空，两个连续使用的符文石上的数字符号必须有共鸣，这种共鸣只有当数字符号中至少包含一个特定的元素——星火（数字 0）、水波（数字 2）或者风语（数字 4）时，才会发生。例如，符号序列 126, 552, 24, 4 中的每对连续符文都包含了至少一个共鸣元素，则它们是一系列成功的巡游；而如果是 15, 51, 5，则不成立，因为它们之间的共鸣元素不包含星火、水波或风语中的任意一个。
小蓝总是先启程，使用他的符文石开启巡游。
你的任务是计算这对魔法使者能够执行的最长时空巡游序列的长度。这样的序列形式为 si1, ti2, si3, ti4, . . .，其中序列索引满足 i1 < i2 < i3 < i4 < . . .，并且序列中每一对相邻的符文石都至少包含一个共鸣元素。
输入格式
输入的第一行包含一个整数 N，表示每位魔法使者持有的符文石数量。第二行包含 N 个整数 s1, s2, · · · , sN ，相邻整数之间使用一个空格分隔，表示小蓝的符文石上刻有的数字符号。第三行包含 N 个整数 t1, t2, · · · , tN ，相邻整数之间使用一个空格分隔，表示小桥的符文石上刻有的数字符号。
输出格式
输出一行包含一个整数，表示小蓝和小桥在遵守所有规则的情况下，最多能进行多少次时空巡游。
样例输入
复制
5 126 393 581 42 44 204 990 240 46 52
样例输出
复制
4
提示
【样例说明】
小蓝和小桥可以选择以下符文石序列进行巡游：
s1(126) → t3(240) → s4(42) → t5(52)
这里，数字 2 作为共鸣元素连接了 s1 和 t3、s4 和 t5，数字 2、4 作为共鸣元素连接了 t3 和 s4。
【评测用例规模与约定】对于 30% 的评测用例，1 ≤ N ≤ 103，1 ≤ si, ti ≤ 105。对于所有评测用例，1 ≤ N ≤ 105，1 ≤ si, ti ≤ 109。
n=int(input())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
A=[0]
B=[0]
for i in range(n):
s=str(a[i])
if( '0' in s or '2' in s or '4' in s) and (i>B[len(B)-1] or i==0) and len(A)==len(B):
A.append(i)
# print(*A)
s = str(b[i])
if ('0' in s or '2' in s or '4' in s) and (i>A[len(A)-1]) and len(B)<len(A):
B.append(i)
# print(*B)
if len(A)==1 or len(B)==1:
print(1)
else:
print(len(A)+len(B)-2)G：缴纳过路费 27🏆
时间限制: 3s 内存限制: 512MB 提交: 158 解决: 1
题目描述
在繁华的商业王国中，N 座城市被 M 条商路巧妙地连接在一起，形成了一个错综复杂的无向图网络。每条商路是双向通行的，并且任意两座城市之间最多只有一条直接的商路。每条商路都有它的规则，其中最引人注目的就是穿过商路，需要缴纳过路费。因此，商人们在选择商路时必须格外认真。
有一位名叫小蓝的商人，他对于商路的花费有着自己独到的见解。在小蓝眼中，一条路线包含一条或多条商路，但路线的成本并不是沿途累积的过路费总和，而是这条路线上最贵的那一次收费。这个标准简单而直接，让他能迅速评估出一条路线是否划算。
于是，他设立了一个目标，即找出所有城市对，这些城市之间的最低路线成本介于他心中预设的两个数 L 和 R 之间。他相信，这样的路线既不会太廉价，以至于路况糟糕；也不会过于昂贵，伤害他精打细算的荷包。
作为小蓝的助手，请你帮助小蓝统计出所有满足条件的城市对数量。
输入格式
输入的第一行包含四个整数 N, M, L, R，表示有 N 座城市和 M 条双向通行的商路，以及小蓝心中预设的最高过路费的下限 L 和上限 R。
接下来 M 行，每行包含三个整数 u, v,w，表示城市 u 和城市 v 之间有一条双向通行的商路，过路费为 w。保证每对城市之间最多只有一条直接的商路。
输出格式
输出一行包含一个整数，表示满足条件的城市对数量。
样例输入
复制
5 5 1 2 1 2 2 1 3 5 1 4 1 2 4 5 2 5 4
样例输出
复制
3
提示
【样例说明】
在样例中，满足条件的城市对有 (1, 2)，(1, 4)，(2, 4)。
【评测用例规模与约定】
对于 30% 的评测用例，1 ≤ N ≤ 103，1 ≤ M ≤ min(2 × 103,N×(N−1)/2)，1 ≤ L ≤ R ≤ 105，1 ≤ u, v ≤ N, u , v，1 ≤ w ≤ 105。
对于所有评测用例，1 ≤ N ≤ 105，1 ≤ M ≤ min(2 × 105,N×(N−1)/2)，1 ≤ L ≤R ≤ 109,1 ≤ u, v ≤ N, u , v，1 ≤ w ≤ 109。
找规律，然后用的并查集
N=int(1e5)+10
p=[i for i in range(N+1)]
cnt=[1]*N
def find(x):
if p[x]!=x:
p[x]=find(p[x])
return p[x]
def merge(a,b):
if find(a)!=find(b):
cnt[find(a)]+=cnt[b]
p[find(b)]=find(a)
n,m,l,r=map(int,input().split())
while m:
m-=1
u,v,w=map(int,input().split())
if l<=w<=r:
merge(u,v)
ans=0
for i in range(1,n+1):
if p[i]==i:
ans+=((cnt[i]*(cnt[i]-1))//2)
print(ans)
H：纯职业小组
总节：
漏缺：time库函数不会用
第二个填空题知识容斥原理忘了
927
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
