✅ 秋招备战指南 ✅

💡 学习建议：

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

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

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

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

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

题目一：小兰的密码重组

1️⃣：理解字符串分割的基本操作和索引计算

2️⃣：掌握字符串拼接和子串提取的方法

难度：简单

这道题考查字符串的基本操作，重点在于理解如何将一个偶数长度的字符串平均分成两部分。通过计算中点位置，我们可以轻松提取前后两个子串，然后进行相应的拼接操作。

题目二：小毛的单词拼图游戏

1️⃣：枚举所有可能的字符串排列组合

2️⃣：对每种排列尝试删除不同位置的字符

3️⃣：维护字典序最小的结果字符串

难度：中等

这道题结合了排列枚举和字符串操作，需要理解全排列的生成方法。由于数据规模较小（），可以使用暴力枚举的方法，通过比较所有可能的结果找出字典序最小的答案。

题目三：小基的雷达覆盖优化

1️⃣：分别考虑雷达站在 轴和 轴上的情况

2️⃣：对于每个点计算雷达站的可行位置区间

3️⃣：使用扫描线算法求解区间覆盖问题

4️⃣：通过二分搜索找到最小可行半径

难度：中等偏难

这道题是一个几何优化问题，需要理解欧几里得距离和区间覆盖的概念。通过将问题转化为一维的区间覆盖问题，我们可以使用二分搜索配合扫描线算法，实现 的高效解法。关键在于正确计算每个点对应的可行区间。

01. 小兰的密码重组器

问题描述

小兰是一名网络安全专家，她正在开发一个新的密码重组系统。该系统需要接收两个字符串：用户的原始密码片段 和一个加密密钥 。为了增强安全性，系统会将密钥 分成两半，把后半部分追加到原始密码 的末尾形成新密码，同时将前半部分作为验证码保存。

给定两个由可见字符和空格组成的字符串 和 ，其中字符串 的长度为偶数。需要将 的后半部分拼接到 的末尾，并输出重组后的密码以及 的前半部分作为验证码。

输入格式

第一行包含一个长度为 的字符串 。

第二行包含一个长度为 的字符串 ，保证 为偶数。

保证 和 中只包含可见字符和空格（ASCII 32 到 126）。

输出格式

第一行输出重组后的密码字符串。

第二行输出验证码字符串。

样例输入

kou
yukari

样例输出

kouari
yuk

数据范围

• 
• 
• 为偶数
• 字符串仅包含 ASCII 32 到 126 的字符

样例	解释说明
样例1	字符串 ，前半部分为 "yuk"，后半部分为 "ari"。将 "ari" 拼接到 "kou" 末尾得到 "kouari"，验证码为 "yuk"

题解

这道题的核心思路很简单：将字符串 平均分成两半，然后进行字符串拼接操作。

首先需要理解题目要求：把字符串 分成长度相等的两部分，将后半部分拼接到字符串 的末尾，同时输出前半部分作为验证码。

解题步骤：

1. 读入两个字符串 和
2. 计算 的长度，找到中间位置
3. 使用字符串切片操作分别获取前半部分和后半部分
4. 将后半部分拼接到 的末尾
5. 按要求输出结果

由于字符串长度最多为 100，直接进行字符串操作即可，时间复杂度为 ，对于给定的数据范围完全可以接受。

需要注意的是，不同编程语言处理字符串的方式可能有所不同，但基本思路都是通过索引来截取字符串的指定部分。

参考代码

• Python

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

def solve():
    # 读取用户密码片段和加密密钥
    pwd = input()
    key = input()
    
    # 计算密钥的中间位置
    mid = len(key) // 2
    
    # 分割密钥为前后两部分
    first_half = key[:mid]  # 前半部分作为验证码
    second_half = key[mid:]  # 后半部分用于拼接
    
    # 生成新密码和验证码
    new_pwd = pwd + second_half
    verify_code = first_half
    
    # 输出结果
    print(new_pwd)
    print(verify_code)

if __name__ == "__main__":
    solve()

• Cpp

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

string generate_pwd(const string& pwd, const string& key) {
    // 计算密钥中间位置
    int mid = key.length() / 2;
    // 返回密码片段与密钥后半部分的拼接
    return pwd + key.substr(mid);
}

string get_verify(const string& key) {
    // 返回密钥的前半部分作为验证码
    int mid = key.length() / 2;
    return key.substr(0, mid);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    string pwd, key;
    // 使用 getline 读取可能包含空格的字符串
    getline(cin, pwd);
    getline(cin, key);
    
    // 生成新密码和验证码
    string new_pwd = generate_pwd(pwd, key);
    string verify = get_verify(key);
    
    // 输出结果
    cout << new_pwd << "\n";
    cout << verify << "\n";
    
    return 0;
}

• Java

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

public class Main {
    
    // 生成新密码的方法
    public static String generatePassword(String pwd, String key) {
        int mid = key.length() / 2;
        // 拼接密码片段和密钥后半部分
        return pwd + key.substring(mid);
    }
    
    // 获取验证码的方法
    public static String getVerifyCode(String key) {
        int mid = key.length() / 2;
        // 返回密钥前半部分
        return key.substring(0, mid);
    }
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        // 读取用户密码片段和加密密钥
        String pwd = br.readLine();
        String key = br.readLine();
        
        // 生成新密码和验证码
        String newPwd = generatePassword(pwd, key);
        String verifyCode = getVerifyCode(key);
        
        // 输出结果
        System.out.println(newPwd);
        System.out.println(verifyCode);
        
        br.close();
    }
}

02. 小毛的单词拼图游戏

问题描述

小毛喜欢玩单词拼图游戏。他有 张单词卡片，每张卡片上写着一个由小写字母组成的单词。小毛可以任意调整这些卡片的排列顺序（但不能改变每张卡片上单词内部的字母顺序），将所有单词按顺序拼接成一个长单词。然后，小毛必须从这个长单词中恰好删除一个字母。

小毛想要得到字典序最小的最终单词。请帮助小毛找出所有可能的操作方案中，能够得到的字典序最小的结果。

输入格式

第一行包含一个正整数 ，表示单词卡片的数量。

第二行包含 个用空格分隔的字符串 ，每个字符串长度在 到 之间，仅由小写字母构成。

输出格式

输出一个字符串，表示所有可能的拼接并删除一个字母后字典序最小的结果。

样例输入

1
za

3
za ba bb

样例输出

a

ababb

数据范围

• 
• 每个字符串长度在 到 之间
• 所有字符串仅由小写字母构成

题解

这道题需要考虑所有可能的排列组合，以及每种排列中删除不同位置字母的情况。

由于 ，我们可以枚举所有的排列（最多 种）。对于每种排列，我们将所有字符串拼接起来，然后尝试删除每个位置的字母，保留字典序最小的结果。

具体算法：

1. 生成所有可能的字符串排列
2. 对每种排列，将字符串按顺序拼接
3. 对拼接后的字符串，尝试删除每个位置的一个字母
4. 比较所有可能的结果，保留字典序最小的

由于每个字符串最长10个字符，总长度最多80个字符，枚举所有删除位置的复杂度也是可以接受的。

时间复杂度为 ，其中 是所有字符串的总长度，在最坏情况下约为 ，完全可以通过。

参考代码

• Python

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

n = int(input())
words = input().split()

best_res = None  # 保存最优结果

# 枚举所有排列
for perm in permutations(range(n)):
    # 按当前排列拼接字符串
    full_str = ''.join(words[i] for i in perm)
    
    # 尝试删除每个位置的字符
    for pos in range(len(full_str)):
        # 生成删除第pos个字符后的字符串
        new_str = full_str[:pos] + full_str[pos + 1:]
        
        # 更新最优结果
        if best_res is None or new_str < best_res:
            best_res = new_str

print(best_res)

• Cpp

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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int n;
    cin >> n;
    vector<string> words(n);
    
    // 读取所有单词
    for (int i = 0; i < n; i++) {
        cin >> words[i];
    }
    
    vector<int> order(n);
    iota(order.begin(), order.end(), 0);  // 初始化排列 [0,1,2,...]
    
    string best_res;
    bool first_try = true;
    
    // 枚举所有排列
    do {
        string full_str;
        // 按当前排列拼接字符串
        for (int idx : order) {
            full_str += words[idx];
        }
        
        // 尝试删除每个位置的字符
        for (int pos = 0; pos < (int)full_str.size(); pos++) {
            string new_str = full_str.substr(0, pos) + full_str.substr(pos + 1);
            
            // 更新最优结果
            if (first_try || new_str < best_res) {
                best_res = new_str;
                first_try = false;