这两天蓝桥杯出分了，主播也是运气爆炸凭借暴力和逻辑推理拿到了蓝桥杯的省一，刚好在备战国赛的过程中复盘一下省赛哪里还可以优化

  1. P16260 [蓝桥杯 2026 省 Python/Java B 组] 和平干饭日

题目描述

铲屎官小蓝家里养了 $26$ 只体型巨大的缅因猫。为了给它们增加生活乐趣，小蓝海淘了一台带有人工智能的 “奇葩喂食器”。

这台喂食器的出粮规则极其反人类：它每天吐出的猫粮颗粒总数，是将从 $1$ 开始的自然数依次拼接而成的整数。

具体来说：

  • 第 $1$ 天，喂食器吐出 $1$ 颗猫粮；
  • 第 $2$ 天，喂食器吐出 $12$ 颗猫粮（将 $1$ 和 $2$ 拼在一起）；
  • 第 $3$ 天，喂食器吐出 $123$ 颗猫粮；
  • ……

如果某天吐出的猫粮总数，能够被这 $26$ 只猫完全平分（即每只猫分到的颗粒数一模一样），它们就会相安无事，这一天被称为 “和平干饭日”。如果不能被完全平分，它们就会为了抢夺残粮而大打出手。

现在，喂食器的运行计划已经设定了整整 $2026$ 天。请你帮忧心忡忡的小蓝算一算，在这 $2026$ 天里，总共有多少天是 “和平干饭日”？

解析：这道题本质上是一个字符串与整形之间转换然后取余的过程，不能通过直接字符串相加后总体取余来算，不然会导致数字太大超出限制，只能每次循环迭代区域然后加到下一个头上

1
2
3
4
5
6
7
8
9
10
c = ''
sum = 0
for i in range(1, 2027):
    c += str(i)
    j = int(c) % 26
    if j == 0: 
        sum += 1
    c = str(int(c) % 26)  

print(sum)

  1. P16261 [蓝桥杯 2026 省 Python/Java B 组] 干涉条纹

题目描述

在国家精密光学实验室中，研究员正利用两组高功率相干激光器进行 “量子干涉条纹” 锁定实验。

设 $1$ 号激光器的输出功率为 $a$（$0 \leq a \leq 20269876543210$），$2$ 号激光器的输出功率为 $b$（$0 \leq b \leq 20260123456789$），其中 $a, b$ 均为非负整数。

物理规律表明，只有当系统总功率 $S = a + b$ 恰好为一个完全平方数时，干涉条纹方可被成功锁定。

请问，一共有多少种不同的功率配给方案 $(a, b)$ 能够使实验成功锁定？由于方案数可能很大，你只需要给出方案数对 $998244353$ 取模后的结果即可。

注意：两个方案 $(a_1, b_1)$ 和 $(a_2, b_2)$ 被认为是不同的，当且仅当 $a_1 \neq a_2$ 或 $b_1 \neq b_2$。

解析：求整数对为平方数的组合，需要考虑到边界已经组合的数字在不同大小时能被几个组合数1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

```python

A = 20269876543210
B = 20260123456789

MOD = 10**9 + 7

ans = 0

i = 0
while i * i <= (A + B):
    S = i * i
    L = max(0, S - B)
    R = min(S, A)
    count = max(0, R - L + 1)
    ans += count
    ans %= MOD    
    i += 1

print(ans)


  1. P16262 [蓝桥杯 2026 省 Python B 组] 定制展示盘

题目描述

小蓝正在设计一款用于存放纪念币的展示盘。

由于加工设备的限制，展示盘的制作必须满足以下条件：

  • 展示盘是一个矩形，由若干行、若干列的槽位组成。
  • 展示盘的行数和每行的槽位数量都至少为 $2$。

小蓝手头共有 $n$ 枚纪念币需要安放，他可以根据需要定制不同规格的展示盘，只要展示盘上的总槽位数量（即行数与每行槽位数的乘积）不少于 $n$ 即可。

加工费用是根据展示盘的总面积（即总槽位数量）来计算的，因此，小蓝希望在满足安放需求和设备限制的前提下，使展示盘的总槽位数量尽可能小。现在，请你帮他计算这个最小值。

输入格式

第一行包含一个正整数 $T$，表示数据的组数。

接下来的 $T$ 行，每行包含一个正整数 $n$，代表小蓝拥有的纪念币总数。

输出格式

输出共 $T$ 行，每行包含一个整数，表示在符合所有要求的情况下，展示盘最少需要包含的槽位总数。

输入输出样例 #1

输入 #1

1
2
3
2
3
5

输出 #1

1
2
4
6

解析：若输入数是质数，输出数+1否则输出原本数（注意最少输出为4）

1
2
3
4
5
6
7
8
9
10
11
T=int(input())
for i in range(T):
    n=int(input())
    bl=True
    for j in range(2,int(n**0.5+1)):
        if n%j==0:
            bl=False
            break
    if bl:
        n+=1
    print(max(4,n))

  1. P16263 [蓝桥杯 2026 省 Python B 组] 密室逃脱开关谜题

题目描述

你被困在一个密室中，面前有一个控制面板，上面有 $n$ 个开关，控制着密室中的 $m$ 盏灯。开关编号为 $0, 1, \dots, n - 1$，灯编号为 $0, 1, \dots, m - 1$。

开关与灯的作用规则如下：

  • 按下第 $i$ 个开关（$0 \leq i < n$），会切换第 $(i \bmod m)$ 盏灯和第 $(2 \times i \bmod m)$ 盏灯的状态。
  • 如果这两个编号相同（即 $i \bmod m = 2 \times i \bmod m$），则只切换这一盏灯的状态；
  • 切换指：如果灯是关闭的则打开，如果是打开的则关闭。

初始时，所有灯都处于关闭状态。你可以按任意次开关，每个开关可以被多次按下（也可以不按）。

你的目标是让所有灯最终都变为打开的状态。现在，请你计算：最少需要按多少次开关才能做到这一点；如果无论如何操作都无法让所有灯同时打开，则输出 $-1$。

输入格式

第一行包含一个整数 $t$，表示测试数据组数。

接下来 $t$ 组数据，每组数据占一行，包含两个整数 $n$ 和 $m$，分别表示开关的数量和灯的数量。

输出格式

对于每组数据，输出一行，包含一个整数，表示最少需要按开关的次数。如果无法让所有灯都打开，输出 $-1$。

输入输出样例 #1

输入 #1

1
2
3
2
4 4
5 5

输出 #1

1
2
3
3

说明/提示

【样例说明】

第一组数据：有 $4$ 个开关（编号 $0$ - $3$）和 $4$ 盏灯（编号 $0$ - $3$）。

开关控制关系：

  • 开关 $0$：控制灯 $0$（同一盏）；
  • 开关 $1$：控制灯 $1$ 和灯 $2$；
  • 开关 $2$：控制灯 $2$ 和灯 $0$；
  • 开关 $3$：控制灯 $3$ 和灯 $2$.

一种最优方案：按开关 $1$、开关 $2$、开关 $3$，共按 $3$ 次。状态变化如下（关 $= 0$，开 $= 1$）：

状态 控制灯 灯 $0$ 灯 $1$ 灯 $2$ 灯 $3$
初始状态 关 关 关 关
按开关 $1$ 灯 $1,2$ 关 开 开 关
按开关 $2$ 灯 $2,0$ 开 开 关 关
按开关 $3$ 灯 $3,2$ 开 开 开 开

第二组数据：有 $5$ 个开关（编号 $0$ - $4$）和 $5$ 盏灯（编号 $0$ - $4$）。

开关控制关系：

  • 开关 $0$：控制灯 $0$（同一盏）；
  • 开关 $1$：控制灯 $1$ 和灯 $2$；
  • 开关 $2$：控制灯 $2$ 和灯 $4$；
  • 开关 $3$：控制灯 $3$ 和灯 $1$；
  • 开关 $4$：控制灯 $4$ 和灯 $3$。

一种最优方案：按开关 $0$、开关 $1$、开关 $4$，共按 $3$ 次。状态变化如下：

状态 控制灯 灯 $0$ 灯 $1$ 灯 $2$ 灯 $3$ 灯 $4$
初始状态 关 关 关 关 关
按开关 $0$ 灯 $0$ 开 关 关 关 关
按开关 $1$ 灯 $1,2$ 开 开 开 关 关
按开关 $4$ 灯 $4,3$ 开 开 开 开 开

解析：主播dfs暴力拿的步骤分，大概就是回溯+枚举出来每个可能的开关组合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
T = int(input())
for i in range(T):
    n, m = map(int, input().split())
    mj = [[i % m, 2 * i % m] for i in range(n)]
    a = [0 for i in range(m)]


    def dfs(i, n, le):
        if i >= le:
            bl = True
            for j in range(m):
                if a[j] % 2 == 0:
                    bl = False
                    break
            if bl:
                return n
            return 10000
        t = dfs(i + 1, n, le)
        a[mj[i][0]] += 1
        if mj[i][0] != mj[i][1]:
            a[mj[i][1]] += 1
        ad = dfs(i + 1, n + 1, le)
        a[mj[i][0]] -= 1
        if mj[i][0] != mj[i][1]:
            a[mj[i][1]] -= 1
        return min(t, ad)


    ans = dfs(0, 0, n)
    if ans == 10000:
        print(-1)
    else:
        print(ans)


  1. P16264 [蓝桥杯 2026 省 Python B 组] 奇偶博弈

题目描述

小蓝和小桥正在玩一个基于数列的博弈游戏。

初始时，给定一个长度为 $N$ 的数列 $W_1, W_2, \dots, W_N$，数列中的每一个元素均为正奇数。

游戏由小蓝先手，两人交替进行操作。在每次操作中，当前操作者需要选择数列中一个严格大于 $0$ 的元素 $W_i$，并将其替换为一个严格小于它的非负整数 $W_i’$（即 $0 \leq W_i’ < W_i$）。

该替换操作必须严格满足以下奇偶性限制：

  1. 若选定的 $W_i$ 为奇数，则必须将其替换为 $W_i - 1$。
  2. 若选定的 $W_i$ 为偶数，则替换后的新数 $W_i’$ 也必须是一个偶数。

当轮到某一方操作时，若其无法进行任何合法的替换，则该方输掉游戏，另一方获胜。

假设小蓝和小桥都绝顶聪明，均采取最优策略，请问最终谁将赢得这场游戏？

输入格式

输入的第一行包含一个整数 $T$，表示测试用例的组数。

接下来依次输入 $T$ 组测试用例。

对于每组测试用例：

  • 第一行包含一个整数 $N$，表示数列的长度。
  • 第二行包含 $N$ 个正奇数 $W_1, W_2, \dots, W_N$，相邻两个数字之间用空格隔开。

输出格式

对于每组测试用例，输出一行结果。如果小蓝获胜，输出 L；如果小桥获胜，输出 Q。

输入输出样例 #1

输入 #1

1
2
3
4
5
2
2
5 1
2
1 1

输出 #1

1
2
L
Q

说明/提示

【评测用例规模与约定】

对于所有的评测用例，$1 \leq T \leq 10^3$，$1 \leq N \leq 10^5$，$1 \leq W_i \leq 10^9$。

保证所有测试用例中 $N$ 的总和不超过 $2 \times 10^5$，且保证初始输入的所有 $W_i$ 均为奇数。

解析：我们注意到，大于 1 的数可以多次操作，而 1 只能操作一次。所以，每个一开始就是 1 的数，都会让轮到它的人浪费掉一回合。双方都会想办法让对方去动这些 1，自己则去动那些大于 1 的数。最后，谁赢只取决于一开始有多少个 1。如果有奇数个 1，小蓝赢；如果有偶数个 1，小乔赢。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
T = int(input())
for i in range(T):
    n = int(input())
    a = list(map(int, input().split()))
    a = sorted(a)
    ans = 0
    if a[0] % 2:
        a[0] -= 1
        ans += 1
    minn = a[0]
    for j in range(1, n):
        if a[j] % 2:
            a[j] -= 1
            ans += 1
        if a[j] >minn:
            ans += 1
    if ans % 2:
        print("L")
    else:
        print("Q")



  1. P16266 [蓝桥杯 2026 省 Python B 组] 星光共鸣

题目描述

小蓝是一名星际探险家。在一次遗迹探索中，他发现了一块“星光石板”。

石板上从左到右一共有 $N$ 个凹槽。对于每个凹槽，小蓝都可以选择嵌入一颗“星之碎片”，记作 $1$；也可以保持空置，记作 $0$。这样一来，整块石板的状态就可以用一个长度为 $N$ 的 $01$ 串来表示。

根据遗迹的记载，石板会对“连续且完整的碎片段”产生共鸣。具体地，对于任意一个连续子区间 $[l, r]$（$1 \leq l \leq r \leq N$），如果这一段对应的凹槽全部都嵌入了碎片，也就是区间内每一位都是 $1$，那么这个区间就会产生一次“星光共鸣”。反之，只要其中出现过一个 $0$，这段区间就不会产生共鸣。

因此，一种填充方案所产生的“星光共鸣总次数”，就等于它的 $01$ 串中“全为 $1$ 的连续子区间”的数量。

例如，当 $N = 4$，石板状态为 $1101$ 时：

  • $[1,1]$、$[2,2]$、$[4,4]$ 对应 $1$，各产生 $1$ 次共鸣；
  • $[1,2]$ 对应 $11$，再产生 $1$ 次共鸣；
  • 其他子区间如 $[2,3]$ 对应 $10$、$[3,4]$ 对应 $01$，这样的区间包含 $0$，不会产生共鸣。

所以该状态一共产生了 $4$ 次共鸣。

现在，小蓝打算枚举所有可能的填充方案。由于每个凹槽只有放与不放两种选择，总共有 $2^N$ 种不同的 $01$ 串。小蓝想知道：在这些方案中，有多少种方案的共鸣总次数至少为 $K$？

由于答案可能很大，请输出满足条件的方案数对 $10^9 + 7$ 取模后的结果。

输入格式

输入仅一行，包含两个整数 $N$ 和 $K$，表示石板上的凹槽数量，以及要求达到的最少“星光共鸣”次数。

输出格式

输出一个整数，表示满足“星光共鸣总次数不少于 $K$”的状态数量。由于答案可能很大，请输出对 $10^9 + 7$ 取模后的结果。

输入输出样例 #1

输入 #1

1
4 4

输出 #1

1
5

说明/提示

【样例说明】

当 $N = 4$、$K = 4$ 时，共有 $5$ 种状态满足条件，分别为：

  • $1110$: 共鸣次数为 $3 + 2 + 1 = 6 \geq 4$；
  • $1101$: 共鸣次数为 $(2 + 1) + 1 = 4 \geq 4$；
  • $1011$: 共鸣次数为 $1 + (2 + 1) = 4 \geq 4$；
  • $0111$: 共鸣次数为 $6 \geq 4$；
  • $1111$: 共鸣次数为 $4 + 3 + 2 + 1 = 10 \geq 4$。

所以答案为 $5$。

【评测用例规模与约定】

对于 $30%$ 的数据，保证 $N \leq 12$；

对于 $100%$ 的数据，保证 $1 \leq N \leq 1000$，$0 \leq K \leq \min(\frac{N(N+1)}{2}, 100)$。

解析：暴力枚举… 部分分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
n, k = map(int, input().split())
a = [0] * n
ans=0


def dfs(i, n):
    global ans
    if i >= n:
        bl = True
        num = 0
        sum = 0

        for j in range(n):
            if a[j] == 1:
                num += 1
                if j + 1 >= n or a[j + 1] == 0:
                    sum += ming(num)
                    num = 0

        if sum >= k:
            ans += 1
        return
    dfs(i + 1, n)
    a[i] = 1
    dfs(i + 1, n)
    a[i] = 0
    return


def ming(n):
    return n * (1 + n) / 2

dfs(0,n)
print(ans)