✅ 春招备战指南 ✅

💡 学习建议：

• 先尝试独立解题（建议用时：90分钟/套）
• 对照解析查漏补缺
• 配套练习题库

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

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

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

2025.03.15-电信题目集合

题目一：音乐节奏优化器

1️⃣：音符序列构建与表示 2️⃣：优先队列（最小堆）应用 3️⃣：贪心策略优化音符持续时间

整体难度：中等

该题目要求通过有限次操作，使所有音符中持续时间最短的那个音符尽可能长。每次操作可以选择一个音符，将其持续时间延长10个单位。关键是将输入字符串转换为音符序列，然后使用优先队列（最小堆）来高效地找到持续时间最短的音符。每次从优先队列中取出持续时间最短的音符，增加其持续时间后再放回队列，重复操作k次。时间复杂度为O(n + k log n)，其中n是音符的数量，k是操作次数。

题目二：情绪识别器

1️⃣：表情符号识别与统计 2️⃣：字符串模式匹配 3️⃣：情感倾向判断逻辑

整体难度：简单

该题目要求统计字符串中两种表情符号(":-)"和":-("）的数量，并根据它们的数量关系判断文本的情感倾向。通过遍历字符串，识别并统计这两种表情符号的出现次数，然后根据统计结果判断情感倾向：高兴表情多则输出"Happy"，难过表情多则输出"Sad"，数量相等且至少各有一个则输出"Just so so"，没有表情则输出"None"。时间复杂度为O(n)，其中n是字符串的长度。

题目三：商场折扣计算器

1️⃣：阶梯式折扣规则应用 2️⃣：条件判断与优惠选择 3️⃣：精确小数计算与格式化

整体难度：简单

该题目要求根据给定的购物金额，计算应用最优惠折扣后的最终支付金额。根据不同的金额阈值（100元、500元、2000元、5000元），分别应用不同的折扣率（9折、8折、7折、6折）。关键是正确判断适用的折扣等级，计算折扣后的金额，并将结果保留一位小数输出。由于只需要进行简单的条件判断和计算，时间复杂度为O(1)。

01. 音乐节奏优化器

问题描述

小基是一位音乐爱好者，她喜欢用字母表示不同的音调： 表示 la， 表示 xi， 表示 do， 表示 re， 表示 mi， 表示 fa， 表示 sol。当一个音调需要延长时间时，小基会使用多个相同的字母来表示该音的持续时间。例如， 表示共有 个音符，分别是：一个持续时间为 的 do，一个持续时间为 的 la，一个持续时间为 的 xi，以及一个持续时间为 的 do。

现在，小基有 次操作机会，每次操作可以选择一个音符，将其持续时间延长 个单位。小基希望通过这些操作，使得最终所有音符中持续时间最短的那个音符尽可能长。

你需要帮助小基设计一个操作方案，并输出最终每个音符的持续时间。

输入格式

第一行输入一个字符串，长度不超过 ，表示小基的音乐序列。字符串仅包含 到 这七种大写字母。

第二行输入一个正整数 ，表示小基可以进行的操作次数。

输出格式

首先输出 行，每行包含一个正整数 和一个字符 ，表示小基对第 个音符进行操作，该音符的音调为 。

最后输出一个字符串，格式为 ，表示最终操作后，每个音符及其持续时间。

如果有多种不同的操作方案，输出任意一种即可。但需要保证最终音符持续时间的最小值是尽可能大的。

样例输入

CCABCC
3

样例输出

2 A
3 B
2 A
C(2)A(21)B(11)C(2)

样例解释

共操作3次。 对第2个音符A操作1次，持续时间变成11。 对第3个音符B操作1次，持续时间变成11。 对第2个音符A再操作1次，持续时间变成21。 操作结束后，音符持续时间的最小值为2。可以证明，这个最小值是尽可能大的。

数据范围

• 字符串长度不超过
• 字符串仅包含 到 这七种大写字母
• 

题解

这道题目要求我们通过有限次操作，使得所有音符中持续时间最短的那个音符尽可能长。

解题思路：

1. 首先，我们需要将输入的字符串转换为音符序列，每个音符包含其音调和持续时间。例如，将"CCABCC"转换为[(C,2), (A,1), (B,1), (C,2)]。
2. 然后，我们需要进行k次操作，每次操作选择持续时间最短的音符，将其持续时间增加10。
3. 如果有多个音符的持续时间相同且最短，我们可以任选其中一个进行操作。

为了高效地找到持续时间最短的音符，我们可以使用优先队列（最小堆）。每次从优先队列中取出持续时间最短的音符，增加其持续时间后再放回队列。

时间复杂度：，其中n是音符的数量，k是操作次数。我们需要O(n)的时间来构建音符序列，然后进行k次操作，每次操作需要O(log n)的时间来维护优先队列。 空间复杂度：，需要存储音符序列和优先队列。

参考代码

Python

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

def optimize_music():
    # 读取输入
    music = input()
    k = int(input())
    
    # 构建音符序列
    notes = []
    i = 0
    note_id = 1
    
    while i < len(music):
        # 找到连续相同的字符
        j = i
        while j < len(music) and music[j] == music[i]:
            j += 1
        
        # 添加音符(持续时间, 音调, 编号)
        duration = j - i
        note = (duration, music[i], note_id)
        notes.append(note)
        note_id += 1
        i = j
    
    # 创建最小堆，按持续时间排序
    heap = [(duration, tone, idx) for duration, tone, idx in notes]
    heapq.heapify(heap)
    
    # 记录每个音符的最终持续时间
    final_durations = {idx: duration for duration, _, idx in notes}
    final_tones = {idx: tone for _, tone, idx in notes}
    
    # 执行k次操作
    operations = []
    for _ in range(k):
        # 取出持续时间最短的音符
        duration, tone, idx = heapq.heappop(heap)
        
        # 记录操作
        operations.append((idx, tone))
        
        # 增加持续时间并放回堆
        new_duration = duration + 10
        final_durations[idx] = new_duration
        heapq.heappush(heap, (new_duration, tone, idx))
    
    # 输出操作序列
    for idx, tone in operations:
        print(f"{idx} {tone}")
    
    # 输出最终结果
    result = ""
    for idx in range(1, note_id):
        result += f"{final_tones[idx]}({final_durations[idx]})"
    
    print(result)

if __name__ == "__main__":
    optimize_music()

C++

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

// 自定义比较函数，按持续时间升序排序
struct CompareNotes {
    bool operator()(const tuple<int, char, int>& a, const tuple<int, char, int>& b) {
        // 如果持续时间不同，按持续时间排序
        if (get<0>(a) != get<0>(b)) {
            return get<0>(a) > get<0>(b);
        }
        // 如果持续时间相同，按编号排序
        return get<2>(a) > get<2>(b);
    }
};

void solve() {
    string music;
    int k;
    cin >> music >> k;
    
    // 构建音符序列
    vector<tuple<int, char, int>> notes;
    int i = 0, note_id = 1;
    
    while (i < music.size()) {
        // 找到连续相同的字符
        int j = i;
        while (j < music.size() && music[j] == music[i]) {
            j++;
        }
        
        // 添加音符(持续时间, 音调, 编号)
        int duration = j - i;
        notes.emplace_back(duration, music[i], note_id++);
        i = j;
    }
    
    // 创建最小堆
    priority_queue<tuple<int, char, int>, vector<tuple<int, char, int>>, CompareNotes> pq;
    for (const auto& note : notes) {
        pq.push(note);
    }
    
    // 记录每个音符的最终持续时间和音调
    unordered_map<int, int> final_durations;
    unordered_map<int, char> final_tones;
    
    for (const auto& [duration, tone, idx] : notes) {
        final_durations[idx] = duration;
        final_tones[idx] = tone;
    }
    
    // 执行k次操作
    for (int i = 0; i < k; i++) {
        // 取出持续时间最短的音符
        auto [duration, tone, idx] = pq.top();
        pq.pop();
        
        // 输出操作
        cout << idx << " " << tone << endl;
        
        // 增加持续时间并放回堆
        duration += 10;
        final_durations[idx] = duration;
        pq.push(make_tuple(duration, tone, idx));
    }
    
    // 输出最终结果
    string result = "";
    for (int idx = 1; idx < note_id; idx++) {
        result += final_tones[idx] + string("(") + to_string(final_durations[idx]) + string(")");
    }
    
    cout << result << endl;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    solve();
    return 0;
}

Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String music = sc.nextLine();
        int k = sc.nextInt();
        
        // 构建音符序列
        List<Note> notes = new ArrayList<>();
        int i = 0, noteId = 1;