✅ 秋招备战指南 ✅

💡 学习建议：

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

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

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

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

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

2025.10.19百度-第二套

题目一：服务大厅排队系统

1️⃣：将客户按奇偶性分为两个队列

2️⃣：偶数队列按降序排序

3️⃣：模拟服务过程：每3个高级会员后服务1个普通会员

难度：简单

这道题目的关键在于理解两个队列的处理规则。需要将输入按奇偶性分类，对偶数队列排序，然后按照规定的服务规则进行模拟输出。考察基本的数组操作、排序和模拟能力。

题目二：幸运数字筛选器

1️⃣：预处理所有不吉利数字（包含9的数及其倍数、9的倍数）

2️⃣：使用布尔数组标记不吉利数字

3️⃣：预处理每个位置后的第一个吉利数字，实现O(1)查询

难度：中等

这道题目结合了数字判断和预处理优化。由于查询量大，必须使用预处理而非暴力判断。关键是理解三条规则的关系，通过标记数组和后缀预处理实现高效查询。考察空间换时间的优化思想。

题目三：手办限购策略

1️⃣：使用动态规划维护不同交易次数下的最大利润

2️⃣：分别记录持有和不持有状态

3️⃣：当k较大时退化为贪心算法

难度：中等偏难

这道题目是经典的股票买卖问题变种，限制了最多k次交易。需要使用动态规划记录每个状态下的最优解，状态转移需要从后往前避免重复使用。考察动态规划的状态设计和转移优化能力。

01. 服务大厅排队系统

问题描述

K 小姐在某服务中心工作，该中心有两类客户：普通会员（会员号为奇数）和高级会员（会员号为偶数）。系统需要将到达的客户按照特定规则安排到两个服务队列中：

• 队列 用于存储普通会员（奇数会员号），按照到达顺序排列。

• 队列 用于存储高级会员（偶数会员号），按照会员号从大到小排序。

服务顺序规则如下：

• 优先服务高级会员（队列 ）。

• 每服务 位高级会员后，必须服务 位普通会员（队列 ）。

• 当某个队列为空时，直接服务剩余队列中的所有客户。

请输出按照上述规则服务后的客户会员号序列。

输入格式

输入一行，包含若干个正整数，表示按到达顺序的客户会员号列表（以空格分隔）。

输出格式

输出一行，包含按服务顺序排列的客户会员号序列（以空格分隔，末尾无多余空格）。

样例输入

8 2 1 3 9 4 11 13 15

样例输出

8 4 2 1 3 9 11 13 15

数据范围

• ，其中 为客户总数。

• 会员号 。

样例	解释说明
样例1	队列 （奇数）：（保持输入顺序）；队列 （偶数）： 降序排序为 。服务顺序：先服务 位高级会员 ；再服务 位普通会员 ；队列 已空，服务队列 剩余客户 。

题解

这道题的核心在于理解两个队列的处理规则。首先需要将输入的会员号分成两类：奇数放入队列 ，偶数放入队列 。

队列 保持输入顺序即可，而队列 需要按照会员号从大到小排序，这样优先服务会员号更大的高级会员。

接下来按照规则模拟服务过程：每次从队列 取出最多 位客户（如果不足 位就全部取出），然后从队列 取出 位客户。重复这个过程直到某个队列为空，最后把另一个队列中的剩余客户全部输出。

整个算法的时间复杂度主要在排序上，为 ，其中 是高级会员的数量。模拟过程只需要 的时间。

参考代码

• Python

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

# 读取输入
nums = list(map(int, input().split()))

# 分离奇数和偶数
odd_q = []  # 普通会员队列
even_q = []  # 高级会员队列

for val in nums:
    if val % 2 == 1:
        odd_q.append(val)
    else:
        even_q.append(val)

# 高级会员按降序排序
even_q.sort(reverse=True)

# 模拟服务过程
res = []
i, j = 0, 0

while i < len(odd_q) and j < len(even_q):
    # 服务最多3位高级会员
    cnt = 0
    while cnt < 3 and j < len(even_q):
        res.append(even_q[j])
        j += 1
        cnt += 1
    
    # 服务1位普通会员
    if i < len(odd_q):
        res.append(odd_q[i])
        i += 1

# 处理剩余客户
while j < len(even_q):
    res.append(even_q[j])
    j += 1

while i < len(odd_q):
    res.append(odd_q[i])
    i += 1

# 输出结果
print(' '.join(map(str, res)))

• Cpp

#include <iostream>
#include <vector>
#include <algorithm>
#include <sstream>
using namespace std;

int main() {
    string line;
    getline(cin, line);
    stringstream ss(line);
    
    vector<long long> odd_q, even_q;  // 奇数队列和偶数队列
    long long num;
    
    // 读取并分类
    while (ss >> num) {
        if (num & 1) {
            odd_q.push_back(num);
        } else {
            even_q.push_back(num);
        }
    }
    
    // 偶数队列降序排序
    sort(even_q.begin(), even_q.end(), greater<long long>());
    
    vector<long long> ans;
    int i = 0, j = 0;
    
    // 模拟服务过程
    while (i < odd_q.size() && j < even_q.size()) {
        // 服务最多3位高级会员
        int cnt = 0;
        while (cnt < 3 && j < even_q.size()) {
            ans.push_back(even_q[j++]);
            cnt++;
        }
        
        // 服务1位普通会员
        if (i < odd_q.size()) {
            ans.push_back(odd_q[i++]);
        }
    }
    
    // 添加剩余客户
    while (j < even_q.size()) ans.push_back(even_q[j++]);
    while (i < odd_q.size()) ans.push_back(odd_q[i++]);
    
    // 输出
    for (int k = 0; k < ans.size(); k++) {
        if (k > 0) cout << " ";
        cout << ans[k];
    }
    cout << endl;
    
    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[] tokens = br.readLine().split(" ");
        
        List<Long> oddList = new ArrayList<>();   // 普通会员队列
        List<Long> evenList = new ArrayList<>();  // 高级会员队列
        
        // 读取并分类
        for (String tok : tokens) {
            long val = Long.parseLong(tok);
            if (val % 2 == 1) {
                oddList.add(val);
            } else {
                evenList.add(val);
            }
        }
        
        // 高级会员降序排序
        evenList.sort(Collections.reverseOrder());
        
        List<Long> result = new ArrayList<>();
        int idxOdd = 0, idxEven = 0;
        
        // 模拟服务过程
        while (idxOdd < oddList.size() && idxEven < evenList.size()) {
            // 服务最多3位高级会员
            int count = 0;
            while (count < 3 && idxEven < evenList.size()) {
                result.add(evenList.get(idxEven++));
                count++;
            }
            
            // 服务1位普通会员
            if (idxOdd < oddList.size()) {
                result.add(oddList.get(idxOdd++));
            }
        }
        
        // 添加剩余客户
        while (idxEven < evenList.size()) {
            result.add(evenList.get(idxEven++));
        }
        while (idxOdd < oddList.size()) {
            result.add(oddList.get(idxOdd++));
        }
        
        // 输出结果
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < result.size(); i++) {
            if (i > 0) sb.append(" ");
            sb.append(result.get(i));
        }
        System.out.println(sb.toString());
    }
}

02. 幸运数字筛选器

问题描述

A 先生正在开发一个幸运数字筛选系统。在这个系统中，某些数字被认为是"不吉利"的，不能出现在结果序列中。

不吉利数字的定义规则如下：

• 规则 ：数字是 的倍数，例如 、。

• 规则 ：数字本身包含数字 ，例如 （个位是 ）、（十位是 ）。

• 规则 ：数字是某个包含数字 的数的倍数。

现在给定一个数字序列，对于每个数字 ，需要判断：

• 如果 是不吉利数字，输出 。

• 如果 是吉利数字，输出比 大的第一个吉利数字。

输入格式

输入一行，格式为 ，表示 个需要判断的正整数（用逗号分隔，外层有方括号）。

输出格式

输出一行，格式为 ，其中 表示对应 的结果（用逗号分隔，外层有方括号）。

样例输入

[8,37,88]

样例输出

[10,40,100]

数据范围

• 。

• 。

样例	解释说明
样例1	对于 ：不是不吉利数字，下一个吉利数字是 （ 是不吉利数字）；对于 ：不是不吉利数字，下一个吉利数字需要跳过 （）、（包含 ），答案是 ；对于 ：不是不吉利数字，下一个需要跳过 、、...、，答案是 。

题解

这道题要求对于每个查询数字，快速判断它是否满足不吉利规则，并找到下一个吉利数字。由于查询量可能很大（最多 次），暴力检查每个数字会超时。

关键思路是预处理。因为数字范围不超过 ，可以预先标记出所有不吉利的数字：

首先找出所有包含数字 的数（从 到 ），对于每个这样的数 ，标记它的所有倍数为不吉利（规则 和规则 ）。

然后标记所有 的倍数为不吉利（规则 ）。

接着从后往前扫描，预处理出每个位置之后的第一个吉利数字。这样对于每次查询，如果当前数字是不吉利的就返回 ，否则返回预处理好的下一个吉利数字。

时间复杂度：预处理 ，单次查询 。空间复杂度 。

参考代码

• Python

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

MAX = 1000000

# 检查是否包含数字9
def has_9(x):
    while x > 0:
        if x % 10 == 9:
            return True
        x //= 10
    return False

# 预处理不吉利数字
ban = [False] * (MAX + 2)

# 规则2和3：包含9的数及其倍数
nine_nums = [i for i in range(1, MAX + 1) if has_9(i)]
for x in nine_nums:
    mult = x
    while mult <= MAX:
        ban[mult] = True
        mult += x

# 规则1：9的倍数
for i in range(9, MAX + 1, 9):
    ban[i] = True

# 预处理下一个吉利数字
nxt = [-1] * (MAX + 2)
cur = -1
for i in range(MAX, -1, -1):
    if not ban[i]:
        cur = i
    nxt[i] = cur

# 读取输入
line = input().strip()
nums = []
temp = 0
in_num = False

for c in line:
    if c.isdigit():
        temp = temp * 10 + int(c)
        in_num = True
    else:
        if in_num:
            nums.append(temp)
            temp = 0
            in_num = False

if in_num:
    nums.append(temp)

# 处理查询
ans = []
for n in nums:
    if ban[n]:
        ans.append(-1)
    else:
        ans.append(nxt[n + 1])

# 输出结果
print('[' + ','.join(map(str, ans)) + ']')