✅ 秋招备战指南 ✅

💡 学习建议：

• 先尝试独立解题
• 对照解析查漏补缺

🧸 题面描述背景等均已深度改编，做法和题目本质基本保持一致。

🍹 感谢各位朋友们的订阅，你们的支持是我们创作的最大动力

🌸 目前本专栏已经上线180+套真题改编解析，后续会持续更新的

春秋招笔试机考招合集 -> 互联网必备刷题宝典🔗

电信-2025.09.27

题目一：小兰的神秘符文

1️⃣：遍历字符串中的每个字符

2️⃣：检查字符是否属于特定集合 {b, p, q, d}

3️⃣：统计符合条件的字符数量

难度：简单

这道题目是一个基础的字符统计问题，核心在于识别特定的字符集合。由于字符串长度固定为3，可以直接遍历每个字符进行判断，时间复杂度为O(1)。解法简单直接，适合作为热身题。

题目二：小基的魔法咒语配制

1️⃣：枚举前两个字母，通过约束计算第三个字母

2️⃣：检查计算得到的第三个字母是否在有效范围内

3️⃣：验证相邻字母的能量差值是否满足和谐约束条件

难度：中等

这道题目结合了枚举搜索和约束检查，需要理解字典序的概念并按序枚举。关键在于发现可以通过枚举前两个字母来唯一确定第三个字母，然后检查所有约束条件。虽然是暴力枚举，但由于搜索空间有限（26×26），效率可以接受。

题目三：小毛的魔法阵修复

1️⃣：维护当前未匹配的开启符号数量

2️⃣：预处理所有开启符号的位置信息

3️⃣：使用贪心策略，遇到无法匹配的封闭符号时与最近的开启符号交换

难度：中等偏难

这道题目是括号匹配的经典变形，需要计算最少交换次数而非简单判断是否平衡。核心思想是贪心策略：当遇到无法就地匹配的右括号时，必须与后面最近的左括号进行交换。通过预处理和双指针技术，可以在O(n)时间内解决，体现了算法优化的重要性。

01. 小兰的神秘符文

问题描述

小兰是一位考古学家，最近她在古代遗迹中发现了一些神秘的符文石板。经过深入研究，她发现这些符文中只有四种特殊的字符具有神秘力量：b、p、q、d。

这四个字符被称为"圣光符文"，因为它们具有独特的对称性质——无论如何旋转或翻转，都能保持其神秘的能量不变。

现在 小兰需要分析一块长度为 的符文石板，帮助她统计其中包含多少个圣光符文。

输入格式

输入一个长度为 、仅由小写字母构成的字符串 。

输出格式

输出一个整数，表示字符串 中圣光符文的个数。

样例输入

bpq

xyz

样例输出

3

0

数据范围

• 输入字符串长度固定为
• 字符串仅包含小写字母

题解

这道题目本质上是一个字符统计问题。我们需要统计给定字符串中特定字符的出现次数。

关键思路：

1. 遍历输入字符串的每个字符
2. 检查该字符是否属于圣光符文集合 {b, p, q, d}
3. 统计符合条件的字符个数

由于字符串长度固定为 3，时间复杂度为 O(3) = O(1)，空间复杂度也是 O(1)。

对于判断字符是否为圣光符文，可以使用简单的条件判断，或者使用集合/数组来优化查找效率。

参考代码

• Python

import sys
input = lambda: sys.stdin.readline().strip()

# 读取输入字符串
s = input()
# 定义圣光符文集合
holy = set(['b', 'p', 'q', 'd'])
# 统计圣光符文数量
cnt = 0
for ch in s:
    if ch in holy:
        cnt += 1
# 输出结果
print(cnt)

• Cpp

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    string s;
    cin >> s;
    
    // 定义圣光符文数组，用于快速查找
    bool holy[26] = {false};
    holy['b' - 'a'] = true;
    holy['p' - 'a'] = true;
    holy['q' - 'a'] = true;
    holy['d' - 'a'] = true;
    
    int cnt = 0;
    // 遍历字符串统计圣光符文
    for (char ch : s) {
        if (holy[ch - 'a']) {
            cnt++;
        }
    }
    
    cout << cnt << "\n";
    return 0;
}

• Java

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        String s = br.readLine().trim();
        
        // 定义圣光符文集合
        Set<Character> holySet = new HashSet<>();
        holySet.add('b');
        holySet.add('p');
        holySet.add('q');
        holySet.add('d');
        
        int count = 0;
        // 遍历字符串统计圣光符文
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (holySet.contains(ch)) {
                count++;
            }
        }
        
        System.out.println(count);
    }
}

02. 小基的魔法咒语配制

问题描述

小基是一位年轻的魔法师，她正在学习古老的咒语配制艺术。每个魔法咒语都由三个魔法字母组成，每个魔法字母都对应一个能量值（从 ）。

为了成功配制一个有效的咒语 ，需要满足两个严格的条件：

1. 能量平衡：三个字母的总能量值必须恰好等于指定的数值 ，即

2. 和谐约束：相邻字母之间的能量差值必须在允许的和谐集合 中，即 且

现在给定总能量值 和允许的和谐差值集合 ，小基想要找到满足条件的咒语中字典序最小的那个。如果不存在这样的咒语，则无法完成配制。

输入格式

每个测试文件包含多组测试数据。第一行输入一个整数 ，代表数据组数。

每组测试数据包含两行：

第一行输入两个整数

第二行输入 个两两不同的整数 ，表示允许的和谐差值集合

输出格式

对于每组测试数据，输出一行：

• 若存在满足条件的咒语，输出由 个小写字母组成的字符串
• 否则输出 NO

样例输入

2
6 1
1
4 1
2

样例输出

abc
NO

样例	解释说明
样例1	。取 ，有 且 $
样例2	。不存在满足条件的三字母组合，输出 NO

数据范围

题解

这道题目的核心是在约束条件下寻找字典序最小的三字母组合。

关键思路：

1. 要使字典序最小，应该优先让第一个字母尽可能小，然后是第二个字母
2. 可以枚举前两个字母 和 ，通过 计算第三个字母
3. 检查 是否在有效范围 内
4. 检查相邻字母的能量差值是否都在允许集合 中

算法步骤：

1. 使用布尔数组存储允许的差值集合，便于 O(1) 查询
2. 按字典序从小到大遍历： 从 1 到 26， 从 1 到 26
3. 对每种组合，计算 并检查所有约束条件
4. 找到的第一个有效组合就是字典序最小的答案

时间复杂度：每组数据最多枚举 种组合，每次检查为 O(1)，总复杂度 O(1)。

参考代码

• Python

import sys
input = lambda: sys.stdin.readline().strip()

t = int(input())
for _ in range(t):
    n, k = map(int, input().split())
    diffs = list(map(int, input().split()))
    
    # 使用集合存储允许的差值
    allow = set(diffs)
    
    ans = ""
    found = False
    
    # 枚举前两个字母，优先字典序小的
    for w1 in range(1, 27):
        if found:
            break
        for w2 in range(1, 27):
            w3 = n - w1 - w2
            # 检查第三个字母是否有效
            if w3 < 1 or w3 > 26:
                continue
            
            # 检查相邻差值约束
            diff1 = abs(w1 - w2)
            diff2 = abs(w2 - w3)
            
            if diff1 in allow and diff2 in allow:
                # 转换为字母并输出
                ans = chr(ord('a') + w1 - 1) + chr(ord('a') + w2 - 1) + chr(ord('a') + w3 - 1)
                found = True
                break
    
    if found:
        print(ans)
    else:
        print("NO")

• Cpp

#include <bits/stdc++.h>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int t;
    cin >> t;
    
    while (t--) {
        int n, k;
        cin >> n >> k;
        
        // 使用布尔数组存储允许的差值
        bool valid[26] = {false};
        for (int i = 0; i < k; i++) {
            int d;
            cin >> d;
            if (d < 26) valid[d] = true;
        }
        
        string res = "";
        bool found = false;
        
        // 枚举前两个字母
        for (int w1 =