碎叨叨#

打车到赛点已经晕死，依旧忘记吃买的面包，依旧忘记吃药，依旧打满4h

A题很简单暴力模拟即可，B题看了一眼纯暴力要花大概14亿天，直接跳了

C题读完题目想着这个位置不就是给我打暴力的吗，直接两个for循环（GG）…

D题读完题目感觉像DP，模拟了几个列子，不太可做，DFS写了暴力 （幸好没做，是蓝题）

E题读完当场直接蒙了一个尼莫博弈 ~~（巴巴博弈），应该是暴0了 ~~？？？

F看题目应该是并查集，但是比较复杂，不是板子题 ~~（板子我也忘记了），直接模拟了，拿了应该40%（赚大了）~~

GH直接暴力，G题目很长，有点复杂，H就很容易暴力了，拿了各40%

暴力专场，A~H可做的都做错了 ~~(活该hhhh)+不可做的全部DFS混分 == 省一（国赛当然也是打暴力了）~~

难度 （个人感觉…）#

Easy: A、B 、C

Mid: E、G、F

Hard: H、D

D不可做 补不了，，，，FGH前置知识有点多，暂时学不会(悲)

• A-模拟

  P16260 [蓝桥杯 2026 省 Python/Java B 组] 和平干饭日 - 洛谷

  直接暴力即可 (毫无新意)

  1
  from sys import *
  2
  set_int_max_str_digits(0)
  3
  cnt=0
  4
  x=''
  5
  for i in range(1,2027):
  6
      x+=str(i)
  7
      x=int(x)
  8
      if x%26==0:
  9
          cnt+=1
  10
      x=str(x)
  11
  print(cnt)

• B-数学

  P16261 [蓝桥杯 2026 省 Python/Java B 组] 干涉条纹 - 洛谷

  特有的B题考数学思维…（我的数学思维呢？？？）

  题意：

  有两个区间$[0,A],[0,B]$各选一个整数$a,b$出来后，要使得 $a+b$ 是一个完全平方数，求方案数。

  其中$A=20269876543210,B=20260123456789$。

  题解：

  显然暴力是不可做的，区间太大了

  换个角度，通过枚举比较少的完全平方数，从0枚举到A+B，

  问题转换为：给定完全平方数S，在两个区间中各选择一个数子，加起来等于等于S有对少种选法。由于S固定，a固定后,b也固定，求a的选法即可。

  $$a + b = k^2$$ $$s = k^2$$ $$a = s - b$$

  由$0≤b≤B$和$0≤a≤A$，有：

  $$s - B ≤ a ≤ s - 0$$ $$max(0,s−B)≤a≤min(s,A)$$ $$合法对数 = min(s,A) - max(s - B,0) + 1$$

  1
  MOD = 998244353
  2
  ans = 0
  3
  A = 20269876543210
  4
  B = 20260123456789
  5
  i = 0
  6
  while i * i <= A + B:
  7
      s = i * i
  8
      l = max(0,s - B)
  9
      r = min(s,A)
  10
      ans += max(0,r - l + 1)
  11
      ans %= MOD
  12
      i += 1
  13
  print(ans)

• C-合数

  P16262 [蓝桥杯 2026 省 Python B 组] 定制展示盘 - 洛谷

  赛时两个for真的丑完了…

  总槽位数量要大于 n 且行数不能等于1，也就是说这个最小数，一定会被大于或等于 2 的数整除，这时我们就会发现，这个最小数一定不是质数，所以我们要求的是不小于 n 且不是质数的最小数，亦即找到一个不小于n的合数。

  1.由于$x,y$都不小于2，答案不小于4

  2.如果$n$本身是不小于4的偶数，则$n$本身就是答案

  3.$n$是一个不小于4的奇数，则$n+1$一定可以

  4.答案不会超过$n+1$，但$n+1$不一定是答案，列如$9 = 3*3$；

  5.从2开始枚举到$\sqrt{n}$，验证n能否写出$x*y$

  1
  import math
  2
  # 求不小于n且不是质数的最小数
  3
  for _ in range(int(input())):
  4
      n = int(input())
  5
      ans = n + (n % 2)
  6
      for i in range(2,math.isqrt(n) + 1):
  7
          if n%i:
  8
              continue
  9
          ans = n
  10
          break
  11
      ans = max(ans,4)
  12
      print(ans)

• E-博弈

  P16264 [蓝桥杯 2026 省 Python B 组] 奇偶博弈 - 洛谷

  一道博弈题目，赛时直接写了尼莫博弈，大错特错（）

  证明很困难，直接贴一个证明链接：

  P16264 [蓝桥杯 2026 省 Python B 组] 奇偶博弈 - 洛谷

  结论是如果数据中”1”的个数为奇数则输出L，和我一起参赛的朋友找出来了这个规律，TQL!!

  证明太困难，不太会，记结论惹（哭）

  关键在于本题中”1”没有博弈点，其本质是交换先后手，当”1”全部被处理后，局面变成了在所有非”1”且全奇数的局面来博弈，

  如果你是先手，

  你只能把a减1，然后a变成了偶数，对方把该数变成0，这个数就不存在了，你又变成了先手，局面与前者又相同

  所以显然的结论：如果 1 有奇数个，则先手必胜；反之先手必败

  1
  for _ in range(int(input())):
  2
      n = int(input())
  3
      a = list(map(int,input().split()))
  4
      cnt = a.count(1)
  5
      if cnt % 2 == 1:
  6
          print("L")
  7
      else:
  8
          print("Q")

• F-并查集/启发式合并

  P16265 [蓝桥杯 2026 省 Python B 组] 蓝小圈 - 洛谷

  非板子题，有点困难，CF1800+分

  难点在于命令2和3，即在于当集合合并时怎么做到使原来集合整体操作互不干扰

  用O(n)查询会超时，过40%

  解决困难点的方法是按秩合并 (不太会)（有时间学一学）

  1
  n,q = map(int,input().split())
  2
  t = [set() for i in range(n)]
  3
  res = [0]*n
  4
  for i in range(q):
  5
      a = list(map(int,input().split()))
  6
      z,x = a[0],a[1]
  7
      if z == 1:
  8
          y = a[2]
  9
          t[y-1].add(x-1)
  10
      elif z == 2:
  11
          y = a[2]
  12
          res[x-1] += y
  13
      elif z == 3:
  14
          y = a[2]
  15
          res[x-1] += y
  16
          for c in t[x-1]:
  17
              res[c] += y
  18
      else:
  19
          print(res[x-1])

  展开收起

  1
  def find(p,x):
  2
      if p[x] != x:
  3
          p[x] = find(p,p[x])
  4
      return p[x]
  5
  def union(p,rank,x,y):
  6
      rx,ry = find(p,x),find(p,y)
  7
      if rx == ry:
  8
          return
  9
      if rank[rx] < rank[ry]:
  10
          p[rx] = p[ry]
  11
      elif rank[rx] > rank[ry]:
  12
          p[ry] = p[rx]
  13
      else:
  14
          p[ry] = p[rx]
  15
          rank[rx] += 1
  16
  def main():
  17
      n,q = map(int,input().split())
  18
      p = list(range(n+1))
  19
      res = [0]*(n+1)
  20
      rank = [1]*(n+1)
  21
      for _ in range(q):
  22
          a = list(map(int,input().split()))
  23
          z,x = a[0],a[1]
  24
          if z == 1:
  25
              y = a[2]
  26
              union(p,rank,x,y)
  27
          elif z == 2:
  28
              y = a[2]
  29
              res[x] += y
  30
          elif z == 3:
  31
              y = a[2]
  32
              for c in range(1,n+1):
  33
                  if find(p,x) == find(p,c):
  34
                      res[c] += y
  35
          else:
  36
              print(res[x])
  37
  if __name__ == "__main__":
  38
      main()

  展开收起

  1
  import sys
  2
  def main():
  3
      input = sys.stdin.readline
  4
      n, q = map(int, input().split())
  5
      fa = list(range(n + 1))
  6
      sz = [1] * (n + 1)
  7
      w = [0] * (n + 1)  # 路径上的累加值
  8
      v = [0] * (n + 1)  # 节点单独加的值
  9
  
  10
      def find(x):
  11
          while x != fa[x]:
  12
              x = fa[x]
  13
          return x
  14
  
  15
      def get(x):
  16
          # 获取节点 x 所在集合的根节点的 w 累加值
  17
          res = 0
  18
          while x != fa[x]:
  19
              res += w[x]
  20
              x = fa[x]
  21
          res += w[x]  # 加上根节点的贡献
  22
          return res
  23
  
  24
      for _ in range(q):
  25
          line = list(map(int, input().split()))
  26
          op = line[0]
  27
  
  28
          if op == 1:
  29
              x, y = line[1], line[2]
  30
              x = find(x)
  31
              y = find(y)
  32
              if x == y:
  33
                  continue
  34
              # 按秩合并，保证 x 是较小的集合
  35
              if sz[x] > sz[y]:
  36
                  x, y = y, x
  37
              fa[x] = y
  38
              sz[y] += sz[x]
  39
              w[x] -= w[y]  # 插值抵消
  40
  
  41
          elif op == 2:
  42
              x, y = line[1], line[2]
  43
              v[x] += y
  44
  
  45
          elif op == 3:
  46
              x, y = line[1], line[2]
  47
              w[find(x)] += y
  48
  
  49
          else:  # op == 4
  50
              x = line[1]
  51
              ans = get(x) + v[x]
  52
              print(ans)
  53
  if __name__ == "__main__":
  54
      main()

  展开收起

  1
  #include <iostream>
  2
  #include <vector>
  3
  using namespace std;
  4
  
  5
  int find(vector<int>& p, int x) {
  6
      if (p[x] != x) {
  7
          p[x] = find(p, p[x]);
  8
      }
  9
      return p[x];
  10
  }
  11
  
  12
  void unionSets(vector<int>& p, vector<int>& rank, int x, int y) {
  13
      int rx = find(p, x);
  14
      int ry = find(p, y);
  15
      if (rx == ry) {
  16
          return;
  17
      }
  18
      if (rank[rx] < rank[ry]) {
  19
          p[rx] = p[ry];
  20
      } else if (rank[rx] > rank[ry]) {
  21
          p[ry] = p[rx];
  22
      } else {
  23
          p[ry] = p[rx];
  24
          rank[rx] += 1;
  25
      }
  26
  }
  27
  
  28
  int main() {
  29
      int n, q;
  30
      cin >> n >> q;
  31
  
  32
      vector<int> p(n + 1);
  33
      vector<int> res(n + 1, 0);
  34
      vector<int> rank(n + 1, 1);
  35
  
  36
      for (int i = 0; i <= n; i++) {
  37
          p[i] = i;
  38
      }
  39
  
  40
      for (int _ = 0; _ < q; _++) {
  41
          int z, x;
  42
          cin >> z >> x;
  43
  
  44
          if (z == 1) {
  45
              int y;
  46
              cin >> y;
  47
              unionSets(p, rank, x, y);
  48
          }
  49
          else if (z == 2) {
  50
              int y;
  51
              cin >> y;
  52
              res[x] += y;
  53
          }
  54
          else if (z == 3) {
  55
              int y;
  56
              cin >> y;
  57
              for (int c = 1; c <= n; c++) {
  58
                  if (find(p, x) == find(p, c)) {
  59
                      res[c] += y;
  60
                  }
  61
              }
  62
          }
  63
          else {
  64
              cout << res[x] << endl;
  65
          }
  66
      }
  67
  
  68
      return 0;
  69
  }

  展开收起

• G-DP

  P16266 [蓝桥杯 2026 省 Python B 组] 星光共鸣 - 洛谷

  题目又臭又长，题意为：

  给定$n,k$，定义一个 01 串每个长度为 $x$的连续 1 段都会提供$x*(x+1)/2$的贡献。

  现在求有多少个长度为 $n$的 01 串其贡献之和（也就是题目的共鸣度）不小于 k。

  DP太困难，现在还在学背包(哭)，直接贴题解代码

  1
  def dfs1(n, k):
  2
      def dfs(pos, last_is_zero, cons_len, cur_val):
  3
          if cur_val >= k:
  4
              return 0
  5
          if pos == n:
  6
              return 1 if cur_val < k else 0
  7
          res = dfs(pos + 1, False, 0, cur_val)
  8
          new_len = cons_len + 1 if last_is_zero else 1
  9
          add = new_len * (new_len + 1) // 2 - cons_len * (cons_len + 1) // 2
  10
          res += dfs(pos + 1, True, new_len, cur_val + add)
  11
          return res
  12
      return dfs(0, False, 0, 0)
  13
  n,k = map(int,input().split())
  14
  print((1 << n) - dfs1(n, k))

  1
  import sys
  2
  MOD = 10 ** 9 + 7
  3
  def ksm(a, b, mod):
  4
      """快速幂 a^b % mod"""
  5
      res = 1
  6
      while b:
  7
          if b & 1:
  8
              res = res * a % mod
  9
          a = a * a % mod
  10
          b >>= 1
  11
      return res
  12
  def main() -> None:
  13
      n,k = map(int,input().split())
  14
      # 特殊情况：k == 0 时直接输出 2^n
  15
      if k == 0:
  16
          print(ksm(2, n, MOD))
  17
          return
  18
      # 题目要求“共鸣值不超过 k-1”的方案数，因此将 k 减 1
  19
      k -= 1
  20
      # f[i][j] : 长度为 i 且共鸣值为 j 的方案数
  21
      # s[i][j] : f[0..i][j] 的前缀和
  22
      f = [[0] * (k + 1) for _ in range(n + 1)]
  23
      s = [[0] * (k + 1) for _ in range(n + 1)]
  24
      # 初始化
  25
      f[0][0] = 1
  26
      s[0][0] = 1
  27
      # 外层遍历共鸣值 j
  28
      for j in range(k + 1):
  29
          # 计算所有 i 的 f[i][j]
  30
          for i in range(1, n + 1):
  31
              # 枚举段尾 l，使区间 [l, i] 构成一个“全0”段
  32
              l = i
  33
              while l >= 1:
  34
                  length = i - l + 1               # 区间长度
  35
                  c = length * (length + 1) // 2   # 该区间产生的共鸣值
  36
                  if j < c:
  37
                      break
  38
                  # 上一个状态的位置：l-2（因为需要间隔至少一个1），且不能小于0
  39
                  prev_i = max(0, l - 2)
  40
                  f[i][j] = (f[i][j] + s[prev_i][j - c]) % MOD
  41
                  l -= 1
  42
          # 计算前缀和 s[i][j]
  43
          for i in range(1, n + 1):
  44
              s[i][j] = (s[i - 1][j] + f[i][j]) % MOD
  45
      total = ksm(2, n, MOD)          # 所有可能的方案总数
  46
      illegal = 0                     # 不合法方案数（共鸣值 ≤ k-1）
  47
      for j in range(k + 1):
  48
          illegal = (illegal + s[n][j]) % MOD
  49
      ans = (total - illegal) % MOD
  50
      print(ans)
  51
  if __name__ == "__main__":
  52
      main()

  展开收起

• H-单调栈+贡献法+二阶前缀和+区间最值

  赛时直接暴力，写的最舒服的暴力，完全用不到脑子 （应该是坏掉了）

  题意：

  给定长度为 n 的整数序列 $a1,a2,…,an$。

  定义函数$f(x)$为整数$x$ 的十进制表示位数。

  需要计算所有子区间 $[l,r]$ 的总贡献和：

  $$\begin{aligned}\\\sum_{l=1}^{n}\sum_{r=l}^{n}f(r-l+1)\times\max_{l\leq i\leq r}a_i\\\end{aligned}$$

  最终答案对 998244353 取模输出。

  直接贴题解吧，比较复杂，类似牛客周赛137的E，但更加复杂，数据范围太大

  1
  MOD = 998244353
  2
  def digit_len(x: int) -> int:
  3
      return len(str(x))
  4
  def main():
  5
      n = int(input())
  6
      a = [0] + list(map(int,input().split()))
  7
      ans = 0
  8
      for l in range(1, n + 1):
  9
          cur_max = 0
  10
          for r in range(l, n + 1):
  11
              cur_max = max(cur_max, a[r])
  12
              length = r - l + 1
  13
              val = digit_len(length) * cur_max
  14
              ans = (ans + val) % MOD
  15
      print(ans)
  16
  if __name__ == "__main__":
  17
      main()

  展开收起

  1
  import sys
  2
  
  3
  MOD = 998244353
  4
  
  5
  def get_f(x: int) -> int:
  6
      if x < 10:
  7
          return 1
  8
      if x < 100:
  9
          return 2
  10
      if x < 1000:
  11
          return 3
  12
      if x < 10000:
  13
          return 4
  14
      if x < 100000:
  15
          return 5
  16
      return 6
  17
  
  18
  def main():
  19
      data = sys.stdin.buffer.read().split()
  20
      if not data:
  21
          return
  22
      it = iter(data)
  23
      n = int(next(it))
  24
      a = [0] * (n + 1)
  25
      for i in range(1, n + 1):
  26
          a[i] = int(next(it))
  27
      f = [0] * (n + 1)
  28
      for i in range(1, n + 1):
  29
          f[i] = get_f(i)
  30
      L = [0] * (n + 2)
  31
      st = []
  32
      for i in range(1, n + 1):
  33
          while st and a[st[-1]] < a[i]:
  34
              st.pop()
  35
          L[i] = st[-1] if st else 0
  36
          st.append(i)
  37
      R = [0] * (n + 2)
  38
      st.clear()
  39
      for i in range(n, 0, -1):
  40
          while st and a[st[-1]] <= a[i]:
  41
              st.pop()
  42
          R[i] = st[-1] if st else n + 1
  43
          st.append(i)
  44
      # 前缀和 s1[i] = sum_{j=1..i} f[j],  s2[i] = sum_{j=1..i} s1[j]
  45
      s1 = [0] * (n + 1)
  46
      s2 = [0] * (n + 1)
  47
      for i in range(1, n + 1):
  48
          s1[i] = (s1[i-1] + f[i]) % MOD
  49
          s2[i] = (s2[i-1] + s1[i]) % MOD
  50
      ans = 0
  51
      for i in range(1, n + 1):
  52
          lc = i - L[i]
  53
          rc = R[i] - i
  54
          if lc > rc:
  55
              lc, rc = rc, lc
  56
          # sum = s2[lc+rc-1] - s2[rc-1] - s2[lc-1] + 2*MOD
  57
          total = (s2[lc + rc - 1] - s2[rc - 1] - s2[lc - 1]) % MOD
  58
          ans = (ans + (a[i] % MOD) * total) % MOD
  59
  
  60
      print(ans)
  61
  if __name__ == "__main__":
  62
      main()

  展开收起

写在最后#

暴力场次全省116/1.4W+（其他人在干什么？？）

评价是水爆了，吐槽鼠科的电脑太烂了，还有各种bug，体验很差，希望国赛在南京的学校能整的好一点（bushi）