前言
昨天蓝桥杯python省赛B组比完，今天在洛谷上估了下分，省一没有意外的话应该是稳了。这篇博文是对省赛试题的复盘，所给代码是省赛提交的代码。PB省赛洛谷题单
试题 A: 攻击次数
思路
这题目前有歧义，一个回合到底是只有一个英雄攻击还是三个英雄都攻击。我以及洛谷测试是按照后者写的。
blood = 2025
for i in range(1,406):
blood -= 5
if i%2==1:blood -= 15
if i%2==0:blood-=2
if i%3==1:blood-=2
if i%3==2:blood-=10
if i%3==0:blood-=7
if blood<=0:
print(i)
break
试题 B: 最长字符串
思路
居然考了文件的读写，并且txt有五万行，所以无法复制粘贴，考场上凭借一点点计算机二级的记忆写了出来，但是答案还是错了。
import os
good = [[] for i in range(12)]
max_len = 0
max_word = 'a'
with open("F:\\2025pb\\LQSP2025_PB\\LQSP2025_PB\\words.txt", 'r') as f:
while True:
word = f.readline()
if not word:break
len_ = len(word)
if len_==1:
good[1].append([word])
if len_>1:
if sorted(word[:-1]) in good[len_-1]:
good[len_].append(sorted(word))
if len_ > max_len:
max_len = len_
max_word = word
if len_ == max_len:
if word < max_word:max_word = word
f.close
print(max_word)
试题 C: LQ 图形
思路
很无脑的一题，没什么好说的
w,h,v = map(int,input().split())
for i in range(1,h+w+1):
if 1<=i<=h:print("Q"*w)
if h<i<=h+w:print("Q"*(w+v))
试题 D: 最多次数
思路
线性DP即可在O(n)复杂度解决，设dp[i]表示到第i个字母为止能切割出的最多单词，状态转移方程：如果第i个字母以及前面两个字母能够组成单词，则dp[i] = dp[i-3]+1，否则继承dp[i]=dp[i-1]
s = input()
n = len(s)
arr = [0] + [i for i in s]
def check(a,b,c):
if a+b+c in ['lqb','lbq','qlb','qbl','blq','bql']:
return True
else:return False
dp = [0 for i in range(n+1)]
for i in range(1,n+1):
if i==1 or i==2:continue
if arr[i] in ['l','q','b']:
if check(arr[i],arr[i-1],arr[i-2]):
dp[i] = dp[i-3]+1
else:dp[i] = dp[i-1]
else:
dp[i] = dp[i-1]
print(dp[-1])
试题 E: A · B Problem
思路
考场上没时间细想，直接用DFS枚举每一种可能，并且剪枝尽可能节约时间。
import sys
sys.setrecursionlimit(100000)
def dfs(depth):
global cnt
if depth==5:
if ls[1]*ls[2] + ls[3]*ls[4] <= L:
cnt+=1
return
for i in range(1,L+1):
ls[depth] = i
if depth==2 and ls[1]*ls[2]>L:break
if depth==3 and ls[1]*ls[2] + ls[3] >L:break
dfs(depth+1)
L = int(input())
ls = [0,0,0,0,0]
cnt = 0
dfs(1)
print(cnt)
试题 F: 园艺
思路
这题乍一看是LIS的板子，但是他添加了必须等间隔这个条件，所以单纯了LIS只能找到最长上升字串的长度，且无法保证间隔。考场上没想明白怎么改，直接暴力。
n = int(input())
h = [0] + list(map(int,input().split()))
max_ = 0
for i in range(1,n):
for j in range(1,n+1):
idx = j
temp = 1
while idx<=n:
if idx+i>n:break
if h[idx+i] > h[idx]:
temp += 1
idx += i
else:break
max_ = max(max_,temp)
print(max_)
试题 G: 书架还原
思路
最少操作次数意味着什么？没有多余的交换。我们可以列一些情况试一下：
任意位置的2本书混乱，只需1次对调即可复原：
任意位置的3本书混乱，只需2次对调即可复原：
同理，任意位置的k本书混乱，只需k-1次对调即可复原。
同时我们发现，这发生错放的k本书之间的互换，不涉及其他无关的书本，如果你在交换这k本书的过程中涉及到了这k本书以外的书，那就说明有多余的操作了，就不是最少操作次数了，不符合题意。
从图论的角度出发，根据以上分析我们发现，如果把书看为节点，需要交换的书本之间一定是联通的，我们可以先对所有书做一个 分组，用并查集的思想，找father节点。最后统计各个集合的点的个数，修复这个集合需要的最少交换次数是点的个数减一。最后加起来就是答案。
father数组是什么？稍加分析发现其实就是题目中所给的当前每本书的编号a1,a2,...,an，他意味着：位置1现在放着编号a1，那么父节点位置a1存在着新书编号a[a1],依次类推，每遇到一个新的点，就把他加入当前集合，最后会找到编号为1的书现在的位置，也就确定了一个集合。
其他的解释看代码注释吧：
n = int(input())
father = [0] + list(map(int,input().split()))
size = [0 for i in range(n+1)] # 记录根节点对应集合的大小
vis = [0 for i in range(n+1)] # 记录每本书是否被遍历（是否已经加入到了某个集合）
for i in range(1,n+1): # 每本书依次遍历
if vis[i]!=0: # 如果当前书已经被加入到了某集合
continue # 跳过
vis[i] = 1 # 否则单开一个集合
son = i # 当前子节点
si = 1 # 新集合的size初始化为1
for _ in range(1,n+1): # 我用循环替代嵌套，书个数n，所以最坏的情况n次循环足够找了
if father[son] != i: # 找父节点，这里没有判断vis==0，因为不可能找到属于其他集合的点
si += 1 # 加入到集合
vis[father[son]] = 1 # 修改vis
son = father[son] # 更新当前子节点
if father[son] == i: # 如果又找回来了i，形成闭环，这个集合就结束了
break
size[i] = si # 根节点i赋值size
num = 0
for x in size: # 遍历每个节点
if x == 0:continue
if x == 1:continue # size==1说明这本书单独为一个集合，说明本来就处于正确的位置上
num = num + x-1 # 对于x本书，需要替换x-1次
print(num) # 打印总的次数
试题 H: 异或和
思路
应该是用异或的性质，但是没时间了，直接暴力求解。
n = int(input())
ls = [0] + list(map(int,input().split()))
ans = 0
for i in range(1,n+1):
for j in range(i+1,n+1):
ans += (ls[i]^ls[j])*(j-i)
print(ans)
总结
用洛谷估分大概71分，整体上看这次省赛比较简单，相比于去年难度要小很多，后面继续加油。
![[数据结构]排序 --2](https://i-blog.csdnimg.cn/direct/4fb02329afd54ebcade86b194165ffd5.png)
