l1 = l.strip().split("\n")
l1 = list(set(l1)) # 去重
l1.sort(key=len) # 按长度排序
seen = set() # 存储排序后的字符串
maxlen = ""
for i in l1:
if len(i) == 1:
seen.add(i)
else:
prefix_sorted = ''.join(sorted(i[:-1]))
if prefix_sorted in seen:
current_sorted = ''.join(sorted(i))
seen.add(current_sorted)
if len(i) > len(maxlen):
maxlen = i
print(maxlen)
elif len(i) == len(maxlen) and i < maxlen:
maxlen = i
print(maxlen)
现在他想从 s 中，尽可能切割出多个他喜欢的单词，请问最多能切割出多少个？单词指的是由若干个连续的字符组成的子字符串。
输入格式
输入一行包含一个字符串 s。
输出格式
输出一行包含一个整数表示答案。
python复制代码
s = input().strip()
count = 0
i = 0
n = len(s)
while i <= n - 3:
if {s[i], s[i+1], s[i+2]} == {'l', 'q', 'b'}:
count += 1
i += 3
else:
i += 1
print(count)
python复制代码
s=input()
num=0
l=["lqb","lbq","qlb","qbl","blq","bql"]
i=0
while i<=len(s)-3:
if s[i:i+3] in l:
num+=1
i+=3
else:
i+=1
print(num)
逻辑问题：
当 i 接近字符串末尾时，i+3 可能超出字符串长度，导致 IndexError。
每次匹配成功后，应该跳过这三个字符（即 i += 3），否则会重复计算。
可能超过时间复杂度的代码示例
1. 暴力枚举所有可能的子串
python复制代码
s = input().strip()
valid_words = {"lqb", "lbq", "qlb", "qbl", "blq", "bql"}
max_count = 0
def backtrack(start, current_count):
global max_count
if start >= len(s):
max_count = max(max_count, current_count)
return
# 尝试切割长度为3的子串
if start + 3 <= len(s) and s[start:start+3] in valid_words:
backtrack(start + 3, current_count + 1)
# 不切割，直接跳过当前字符
backtrack(start + 1, current_count)
backtrack(0, 0)
print(max_count)
2. 递归回溯
python复制代码
s = input().strip()
valid_words = {"lqb", "lbq", "qlb", "qbl", "blq", "bql"}
memo = {}
def dp(start):
if start >= len(s):
return 0
if start in memo:
return memo[start]
max_cuts = 0
# 尝试切割当前位置开始的子串
if start + 3 <= len(s) and s[start:start+3] in valid_words:
max_cuts = 1 + dp(start + 3)
# 不切割，继续下一个位置
max_cuts = max(max_cuts, dp(start + 1))
memo[start] = max_cuts
return max_cuts
print(dp(0))
L = int(input())
count = 0
for xa in range(1, L + 1):
for ya in range(1, L + 1):
for xb in range(1, L + 1):
for yb in range(1, L + 1):
if xa * xb + ya * yb <= L:
count += 1
print(count)
2. 优化枚举
python复制代码
L = int(input())
count = 0
for xa in range(1, L + 1):
for ya in range(1, L + 1):
# 对于固定的 xa、ya，求满足 xb*xa + yb*ya <= L 的 (xb, yb) 正整数对数量
max_sum = L
for xb in range(1, L + 1):
# 计算当前 xb 下，yb 满足 ya*yb <= max_sum - xa*xb
remain = max_sum - xa * xb
if remain <= 0:
break
# yb 至少为 1，最多为 remain // ya
max_yb = remain // ya
if max_yb >= 1:
count += max_yb
print(count)
3.数学优化（数论 + 前缀和）
python复制代码
L = int(input())
ans = 0
a = [0] * (L + 1) # a[s] 表示 s 的约数个数（即 YA*YB=s 的对数）
b = [0] * (L + 1) # b[t] 表示前缀和 sum_{k=1}^t a[k]（即 XA*XB≤t 的对数）
# 步骤1：计算每个数的约数个数（O(L log L)）
for i in range(1, L + 1):
for j in range(i, L + 1, i):
a[j] += 1 # 约数个数计数器 +1
# 步骤2：计算约数个数的前缀和（O(L)）
for i in range(1, L + 1):
b[i] = b[i-1] + a[i] # 前缀和数组
# 步骤3：统计答案（O(L)）
for i in range(1, L + 1):
ans += a[i] * b[L-i] # 统计答案
print(ans)
步骤1：计算约数个数：
使用类似筛法的方式，遍历每个数 i 的倍数 j，统计 j 的约数个数。时间复杂度为 O(L log L)。
步骤2：计算前缀和：
计算 a 数组的前缀和 b，使得 b[t] 表示 sum_{k=1}^t a[k]。时间复杂度为 O(L)。
步骤3：统计答案：
对于每个 i，a[i] 是 YA * YB = i 的对数，b[L - i] 是 XA * XB ≤ L - i 的对数。将两者相乘并累加得到最终答案。时间复杂度为 O(L)。
小蓝从左到右种了 n 棵小树，第 i 棵树的高度为 hi，相邻树的间隔相同。小蓝想挪走一些树使得剩下的树等间隔分布，且从左到右高度逐渐上升（相邻两棵树高度满足右边的比左边的高），小蓝想知道最多能留下多少棵树。
输入格式
输入的第一行包含一个正整数 n。
第二行包含 n 个正整数 h1,h2,⋯,hn，相邻整数之间使用一个空格分隔。
输出格式
输出一行包含一个整数表示答案。
1. 暴力枚举法（Brute Force）
枚举所有可能的起点 i 和间隔 d ，从起点开始按固定间隔 d 遍历数组，统计满足严格递增条件的最长子序列长度。
关键逻辑 ：对于每个 i 和 d，逐个检查后续元素是否递增，若不满足则终止当前检查。
python复制代码
n = int(input())
h = list(map(int, input().split()))
if n == 0:
print(0)
max_len = 1 # 至少保留1棵树
for i in range(n):
for d in range(1, n): # 间隔d从1到n-1（至少间隔1个位置）
current_pos = i
current_len = 1 # 初始包含起点
prev_height = h[current_pos]
next_pos = current_pos + d
while next_pos < n:
if h[next_pos] > prev_height:
current_len += 1
prev_height = h[next_pos]
current_pos = next_pos
next_pos = current_pos + d
else:
break # 不满足递增，提前终止
# 即使循环提前终止，current_len至少为1（起点），但有效子序列需至少2个元素
if current_len >= 2: # 确保子序列长度≥2
if current_len > max_len:
max_len = current_len
print(max_len)
2. 动态规划 (O (n²))
思路 ：用 dp[i][d] 表示以第 i 棵树结尾、间隔为 d 的最长序列长度。
python复制代码
n = int(input())
a = list(map(int, input().split()))
dp = [[1] * (n + 1) for i in range(n)]
for i in range(n):
for j in range(i):
if a[i] > a[j]: # 满足高度递增
d = i - j # d为两树之间间隔
dp[i][d] = max(dp[i][d], dp[j][d] + 1)
ans = 0
for row in dp:
if max(row) > ans: # 找最大值
ans = max(row)
print(ans)
n = int(input())
nums = list(map(int, input().split()))
ans = 0
for i in range(n):
for j in range(i+1, n):
x = j - i # 计算下标差
ans += (nums[i] ^ nums[j]) * x # 异或结果乘以坐标差，累加到答案中
print(ans)
