✅ 秋招备战指南 ✅

💡 学习建议：

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

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

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

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

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

得物

题目一：数字密码的奥秘

1️⃣：使用埃拉托斯特尼筛法预处理素数表

2️⃣：遍历区间内每个素数，检查所有可能的分割点

3️⃣：验证分割后的两部分是否都是素数

难度：中等

这道题目的关键在于理解可拆分素数的概念，并通过高效的素数筛选和分割检查来解决问题。通过预处理素数表，我们可以在 时间内判断一个数是否为素数，然后对每个候选数字进行分割验证，实现了 的时间复杂度。

题目二：图书馆的最佳座位

1️⃣：使用滑动窗口技术计算连续k个座位的舒适度总和

2️⃣：记录最大和对应的起始位置，优先选择最左边的方案

3️⃣：返回最优区间的中心位置作为答案

难度：中等

这道题目是经典的滑动窗口最大值问题的变种。通过维护固定大小的窗口并动态更新窗口和，我们可以在 时间内找到最优解。关键在于理解滑动窗口的原理以及如何处理多个最优解的情况（选择最左边的）。

题目三：快递员的最优路线

1️⃣：计算每种配送方式的时间成本

2️⃣：使用贪心策略，优先选择节省时间最多的配送堆使用电动车

3️⃣：通过排序找出前K个最大收益，计算最优总时间

难度：中等

这道题目结合了贪心算法的思想，需要理解如何通过局部最优选择达到全局最优。通过计算每种选择的收益并按收益排序，我们可以保证选择的K个电动车使用方案能够最大化时间节省，从而得到最优解。时间复杂度为 。

01. 数字密码的奥秘

问题描述

小兰是一名密码学爱好者，她最近在研究一种特殊的数字密码系统。在这个系统中，一个数字如果同时满足以下条件，就被称为"完美密码"：

1. 这个数字本身是一个素数

2. 可以将这个数字从某个位置分割成两部分，使得左边部分和右边部分都是素数

例如，数字 就是一个完美密码，因为它本身是素数，且可以分割为 （素数）和 （素数）。

现在给定一个区间 ，小兰想知道这个区间内有多少个完美密码。

输入格式

输入两个正整数 和 （），数字间空格隔开。

输出格式

输出 和 之间完美密码的个数（包含 和 ）。

样例输入

10 100

样例输出

4

样例	解释说明
样例1	在区间 内，完美密码有：（可分为 和 ）、（可分为 和 ，但 不是素数，所以不行；或分为 整体，但需要两部分）等等，共 个

数据范围

题解

这道题本质上是要找出区间内所有可以分割成两个素数的素数。解题思路如下：

首先用埃拉托斯特尼筛法预处理出 到 范围内的所有素数。这一步的时间复杂度是 。

然后遍历区间 内的每个数字，如果这个数字本身是素数，就检查它是否可以分割。检查方法是枚举所有可能的分割点：

对于一个数字 ，设它有 位，那么可能的分割点有 个。对于每个分割点，计算左边部分和右边部分的值，检查这两个值是否都是素数。

具体实现时，可以用 的幂次来进行分割。对于数字 ，用 得到前面部分，用 得到后面部分，其中 从 遍历到 。

时间复杂度分析：预处理素数表需要 时间，遍历区间内的素数大约有 个，每个素数最多检查 个分割点，总时间复杂度约为 ，对于 完全可以接受。

参考代码

• Python

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

def sieve(n):
    """埃拉托斯特尼筛法生成素数表"""
    is_p = [True] * (n + 1)
    is_p[0] = is_p[1] = False
    
    for i in range(2, int(n**0.5) + 1):
        if is_p[i]:
            for j in range(i*i, n + 1, i):
                is_p[j] = False
    return is_p

def solve():
    m, n = map(int, input().split())
    
    # 预处理素数表
    max_val = 1000000
    is_prime = sieve(max_val)
    
    cnt = 0
    # 遍历区间内的每个素数
    for num in range(m, n + 1):
        if not is_prime[num]:
            continue
            
        # 检查是否可拆分
        temp = num
        divisor = 10
        can_split = False
        
        while divisor <= temp // 10:
            left = temp // divisor  # 高位部分
            right = temp % divisor  # 低位部分
            
            # 避免右边部分有前导0
            if right > 0 and is_prime[left] and is_prime[right]:
                can_split = True
                break
                
            divisor *= 10
        
        if can_split:
            cnt += 1
    
    print(cnt)

solve()

• Cpp

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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int m, n;
    cin >> m >> n;
    
    // 埃拉托斯特尼筛法生成素数表
    const int MAX_N = 1000000;
    vector<bool> is_p(MAX_N + 1, true);
    is_p[0] = is_p[1] = false;
    
    for (int i = 2; i * i <= MAX_N; i++) {
        if (is_p[i]) {
            for (int j = i * i; j <= MAX_N; j += i) {
                is_p[j] = false;
            }
        }
    }
    
    int ans = 0;
    // 遍历区间内的每个数
    for (int num = m; num <= n; num++) {
        if (!is_p[num]) continue;
        
        // 检查是否可拆分
        for (int div = 10; div <= num / 10; div *= 10) {
            int hi = num / div;  // 高位部分
            int lo = num % div;  // 低位部分
            
            if (is_p[hi] && is_p[lo]) {
                ans++;
                break;
            }
        }
    }
    
    cout << ans << "\n";
    return 0;
}

• Java

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

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] input = br.readLine().split(" ");
        int m = Integer.parseInt(input[0]);
        int n = Integer.parseInt(input[1]);
        
        // 埃拉托斯特尼筛法生成素数表
        final int MAX_VAL = 1000000;
        boolean[] isPrime = new boolean[MAX_VAL + 1];
        Arrays.fill(isPrime, true);
        isPrime[0] = isPrime[1] = false;
        
        for (int i = 2; i * i <= MAX_VAL; i++) {
            if (isPrime[i]) {
                for (int j = i * i; j <= MAX_VAL; j += i) {
                    isPrime[j] = false;
                }
            }
        }
        
        int result = 0;
        // 遍历区间内每个数
        for (int num = m; num <= n; num++) {
            if (!isPrime[num]) continue;
            
            // 检查能否拆分
            for (int divisor = 10; divisor <= num / 10; divisor *= 10) {
                int highPart = num / divisor;  // 前面部分
                int lowPart = num % divisor;   // 后面部分
                
                if (isPrime[highPart] && isPrime[lowPart]) {
                    result++;
                    break;
                }
            }
        }
        
        System.out.println(result);
    }
}

02. 图书馆的最佳座位

问题描述

小毛是大学里的一名研究生，他经常需要在图书馆学习。图书馆有一排座位，每个座位都有一个舒适度评分，座位从左到右依次编号为 到 。

小毛有一个特殊的习惯：他需要选择连续的 个座位来放置他的学习资料和个人物品。为了获得最佳的学习环境，他希望选择的这 个座