✅ 秋招备战指南 ✅

💡 学习建议：

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

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

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

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

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

拼多多

题目一：密码学家的挑战

1️⃣：分析加密过程中相邻子串的拼接规律

2️⃣：找到原字符串中每个字符在加密串中的位置模式

3️⃣：按奇数位置提取字符恢复原始信息

难度：简单

这道题的核心在于理解字符串拼接的规律。通过观察加密过程可以发现，除第一个字符外，原字符串的每个字符都会在加密串中连续出现两次。利用这个规律，可以通过简单的位置提取来恢复原始字符串。

题目二：项目经理的难题

1️⃣：将问题建模为带截止日期的调度优化问题

2️⃣：使用贪心策略配合优先队列维护可用时段

3️⃣：按时间顺序处理，始终保持成本最优的时段组合

难度：中等偏难

这道题目结合了贪心算法和数据结构的应用。关键在于理解每天获得的"时段"和需要完成的"项目"之间的匹配关系，通过最大堆来维护当前最昂贵的时段，及时剔除多余的高成本时段。

题目三：魔法师的能量平衡

1️⃣：将子段和等于长度的条件转化为前缀和问题

2️⃣：利用数学变换得到等价的键值匹配条件

3️⃣：使用哈希表统计相同键值的出现次数

难度：中等

这道题的精髓是通过数学变换将原问题转化为更容易处理的形式。通过定义 ，将复杂的子段条件判断转化为简单的哈希表查询，大大降低了算法复杂度。

题目四：考试策略大师

1️⃣：分析得分公式中正负贡献位置的分布规律

2️⃣：处理重叠位置对贡献的影响，计算净贡献位置数

3️⃣：采用贪心策略，将最优分值分配给对应贡献位置

难度：中等偏难

这道题目考查的是组合优化和数论知识的结合。需要深入理解最小公倍数的概念，以及如何通过贪心策略来最大化目标函数。排序和前缀和的预处理技巧也是解题的关键。

01. 密码学家的挑战

问题描述

小兰是一位出色的密码学家，最近她收到了一份神秘的加密文件。经过初步分析，她发现这是一种特殊的编码方式：原始信息是由小写英文字母组成的字符串，长度至少为 。

加密过程如下：

• 从左到右扫描原始字符串，提取所有长度为 的连续子串

• 将这些子串按提取顺序直接拼接成加密字符串

现在小兰拿到了加密后的字符串，需要破译出原始信息。

输入格式

第一行包含一个由小写英文字母组成的字符串，表示加密后的信息。

输出格式

输出一行，表示解密后的原始字符串。

样例输入

abbaac

bccddaaf

样例输出

abac

bcdaf

数据范围

• 
• 输入字符串只包含小写英文字母

题解

这道题其实是一个字符串解析问题。关键在于理解加密过程，然后找到逆向规律。

假设原始字符串为 ，那么长度为 的子串依次是：

• 
• 
• 
• ...
• 

这些子串拼接后形成：

仔细观察拼接结果的规律：

• 位置 是
• 位置 是 ，位置 也是
• 位置 是 ，位置 也是
• ...

可以发现，除了第一个字符外，每个原字符都会出现两次，且出现在相邻的位置上。

因此解密策略是：

1. 取加密字符串的第一个字符作为原字符串的第一个字符
2. 从位置 开始，每隔一个位置取一个字符，即取位置 的字符

这样就能完整恢复原始字符串。时间复杂度为 ，其中 是加密字符串的长度。

参考代码

Python

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

def solve():
    s = input()  # 加密后的字符串
    ans = []
    
    # 取第一个字符
    ans.append(s[0])
    
    # 从位置1开始，每隔2个位置取一个字符
    for i in range(1, len(s), 2):
        ans.append(s[i])
    
    print(''.join(ans))

if __name__ == "__main__":
    solve()

Cpp

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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    string s;
    cin >> s;  // 读入加密字符串
    
    string res;
    res.reserve(s.size() / 2 + 1);  // 预分配内存
    
    // 添加第一个字符
    res.push_back(s[0]);
    
    // 提取奇数位置的字符
    for (int i = 1; i < s.size(); i += 2) {
        res.push_back(s[i]);
    }
    
    cout << res << '\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 cipher = br.readLine();  // 加密字符串
        StringBuilder origin = new StringBuilder();
        
        // 添加第一个字符
        origin.append(cipher.charAt(0));
        
        // 从位置1开始每隔2个位置取字符
        for (int idx = 1; idx < cipher.length(); idx += 2) {
            origin.append(cipher.charAt(idx));
        }
        
        System.out.println(origin.toString());
    }
}

02. 项目经理的难题

问题描述

小毛是一名项目经理，他负责安排公司的软件开发任务。公司有一个开发团队，在接下来的 天里，每天的人力成本和可承接的任务数量都已经确定。

现在有 个紧急项目需要安排，每个项目都有一个严格的截止日期，必须在该日期之前完成。小毛希望合理安排这些项目，使总的人力成本最小。

每天最多只能安排固定数量的项目，超过这个数量团队就无法保证质量。请你帮小毛计算出完成所有项目的最小成本。

输入格式

第一行包含三个正整数 、、，分别表示计划天数、项目数量和每天最多可安排的项目数。

第二行包含 个非负整数 ，表示第 天安排一个项目的成本。

第三行包含 个正整数 ，表示第 个项目必须在第 天或之前完成。

输出格式

输出一个整数，表示完成所有项目的最小总成本。

样例输入

3 4 2
3 2 1
1 2 2 3

样例输出

8

数据范围

• 
• 
• 
• 保证在 天内可以完成所有项目

题解

这是一个经典的带截止日期的调度优化问题，可以用贪心算法配合优先队列来解决。

核心思路是：我们按时间顺序处理每一天，维护当前应该安排的项目，并且始终选择成本最低的时间段来完成这些项目。

具体算法：

1. 统计每个截止日期对应的项目数量
2. 按天从1到n遍历，维护一个最大堆来存储可用的时间段（按成本从高到低）
3. 对于第i天，我们获得x个成本为a[i]的时间段
4. 同时，截止日期为i的项目必须安排完成
5. 如果可用时间段超过需要安排的项目数，就移除成本最高的时间段

这样可以保证我们始终使用成本最低的时间段来完成项目。

算法的关键在于理解：每天我们都会获得一些新的"工作时段"，但同时也有一些项目必须在当天截止前完成。我们要做的就是合理分配这些时段，让总成本最小。

时间复杂度为 ，空间复杂度为 。

参考代码

Python

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

def solve():
    n, m, x = map(int, input().split())
    cost = [0] + list(map(int, input().split()))  # 每天成本，下标从1开始
    
    # 统计每个截止日期的项目数
    due_cnt = [0] * (n + 1)
    for _ in range(m):
        d = int(input())
        due_cnt[d] += 1
    
    # 最大堆存储 (-成本, 数量)，Python默认最小堆
    heap = []
    total = 0  # 总成本
    need = 0   # 需要安排的项目数
    avail = 0  # 可用时段总数
    
    for day in range(1, n + 1):
        # 添加当天可用时段
        heapq.heappush(heap, (-cost[day], x))
        avail += x
        need += due_cnt[day]
        
        # 移除多余的高成本时段
        while avail > need:
            neg_c, cnt = heapq.heappop(heap)
            remove = min(avail - need, cnt)
            cnt -= remove
            avail -= remove
            if cnt > 0:
                heapq.heappush(heap, (neg_c, cnt))
    
    # 计算总成本
    while heap:
        neg_c, cnt = heapq.heappop(heap)
        total += (-neg_c) * cnt
    
    print(total)

if __name__ == "__main__":
    solve()

Cpp

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

struct Slot {
    long long cost;
    int cnt;
    bool operator<(const Slot& other) const {
        return cost < other.cost;  // 最大堆
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int n, m, x;
    cin >> n >> m >> x;
    
    vector<long long> a(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    
    vector<int> due(n + 1, 0);
    for (int i = 0; i < m; i++) {
        int d;
        cin >> d;
        due[d]++;
    }
    
    priority_queue<Slot> pq;  // 最大堆
    long long ans = 0;
    long long need = 0, avail = 0;
    
    for (int day = 1; day <= n; day++) {
        // 添加当天的时段
        pq.push({a[day], x});
        avail += x;
        need += due[day];
        
        // 移除多余的高成本时段
        while (avail > need) {
            auto cur = pq.top();
            pq.pop();
            
            long long rm = min(avail - need, (long long)cur.cnt);
            cur.cnt -= rm;
            avail -= rm;
            
            if (cur.cnt > 0) {
                pq.push(cur);
            }
        }
    }
    
    // 计算总成本
    while (!pq.empty()) {
        auto cur = pq.top();
        pq.pop();
        ans += cur.cost * cur.cnt;
    }
    
    cout << ans << '\n';
    return 0;
}

Java

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

class TimeSlot {
    long cost;
    int count;
    
    TimeSlot(long c, int cnt) {
        cost = c;
        count = cnt;
    }
}

public class Main {
    public static void main(String[] args) throws IOException {