第1题：LLM 分词基石：BPE 算法模拟

大语言模型无法直接理解文本，需要将文本切分成 Token。

BPE (Byte Pair Encoding) 算法的核心思想是：迭代合并最高频的相邻字符对。

给定一个由小写字母组成的初始字符串和最大合并次数 K，模拟 BPE 算法的迭代过程。

题目描述

大模型理解文本的第一步是将字符序列转换为 Token 序列。BPE 算法通过不断合并高频词对来构建词表。

迭代规则

在每一轮迭代中：

输入描述

第一行包含一个整数 K，表示最大合并次数。

第二行包含一个字符串 S。

输出描述

输出一行表示经过合并后的序列，Token 之间用空格分隔。

样例 1

输入

5aaabdaaabac

输出

aaab d aaab a c

样例 2

输入

2ababac

输出

ab ab a c

解题思路

初始时将字符串中的每个字符视为独立的 Token。每一轮统计所有相邻对的频率，选出出现次数最多且字典序最小的一对。然后从左到右扫描序列，如果遇到该对则合并，并跳过已被合并的 Token。

更加详细解题思路和CPP、Java代码加我微信获取）

# 题目 1: BPE 分词算法模拟
def simulate_bpe(max_merges, text):
    # 初始状态，每个字符都是一个独立的 Token
    token_list = list(text)

    # 开始迭代合并，最多执行 max_merges 次
    for _ in range(max_merges):
        # 如果 Token 数量不足 2，无法继续合并
        if len(token_list) < 2:
            break

        pair_counts = {}
        # 统计所有相邻 Token 对出现的频率
        for i in range(len(token_list) - 1):
            pair = (token_list[i], token_list[i + 1])
            pair_counts[pair] = pair_counts.get(pair, 0) + 1

        target_pair = None
        max_frequency = 0
        # 寻找出现次数最多且字典序最小的相邻对
        for pair in pair_counts:
            if pair_counts[pair] > max_frequency:
                max_frequency = pair_counts[pair]
                target_pair = pair
            elif pair_counts[pair] == max_frequency:
                if pair < target_pair:
                    target_pair = pair

        # 如果最高频率仅为 1，说明没有重复的对，提前结束
        if max_frequency <= 1:
            break

        merged_tokens = []
        idx = 0
        # 按照从左到右的贪心原则进行合并
        while idx < len(token_list):
            # 检查当前位置和下一个位置是否匹配目标对
            if idx + 1 < len(token_list) and token_list[idx]  target_pair[0] and token_list[idx + 1]  target_pair[1]:
                # 合并成一个新 Token
                merged_tokens.append(token_list[idx] + token_list[idx + 1])
                # 跳过已合并的两个 Token
                idx += 2
            else:
                # 保持原样
                merged_tokens.append(token_list[idx])
                idx += 1

        token_list = merged_tokens

    return token_list
def run_task():
    import sys
    # 获取输入流中的所有内容
    input_data = sys.stdin.read().split()
    if not input_data:
        return

    # 读取最大合并次数
    merge_limit = int(input_data[0])
    # 读取初始字符串
    source_string = input_data[1]

    # 执行 BPE 模拟
    result_tokens = simulate_bpe(merge_limit, source_string)

    # 打印合并后的 Token 序列，以空格分隔
    print(" ".join(result_tokens))
if __name__ == "__main__":
    run_task()

第2题：深度学习底层：2D 空洞卷积实现

空洞卷积（膨胀卷积）是卷积神经网络中扩大特征感受野的核心操作。本题要求手动实现单通道 2D 空洞卷积。

题目描述

空洞卷积通过在卷积核元素之间插入空洞（不增加参数），使得相同的卷积核可以覆盖更大的感受野。

计算步骤

输入描述

输入特征图的大小。

输入特征图的元素。

卷积核的大小。

卷积核的元素。

步长、填充和膨胀率。

输出描述

逐行返回卷积后的二维特征图。

样例 1

输入

4 61 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 2431 0 -1 1 0 -1 1 0 -11 1 2

输出

-32 -8 -8 30-20 -8 -8 18

解题思路

直接模拟二维空洞卷积。遍历输出矩阵的每个位置，计算其在原图（带填充）中的窗口起始坐标。对于卷积核中的每一个位置，通过膨胀率映射到窗口中的具体元素进行乘加。若坐标落在填充区域，则视为 0。

更加详细解题思路和CPP、Java代码加我微信获取）

# 题目 2: 2D 单通道空洞卷积底层实现
import sys
def perform_dilated_convolution():
    # 从标准输入读取所有数据并按空格切分
    raw_input = sys.stdin.read().split()
    if not raw_input:
        return

    ptr = 0

    # 1. 读取输入特征图的尺寸
    height = int(raw_input[ptr])
    width = int(raw_input[ptr + 1])
    ptr += 2

    # 2. 读取特征图元素并构建二维列表
    feature_map = []
    for r in range(height):
        row_data = [int(x) for x in raw_input[ptr : ptr + width]]
        feature_map.append(row_data)
        ptr += width

    # 3. 读取卷积核的尺寸
    kernel_size = int(raw_input[ptr])
    ptr += 1

    # 4. 读取卷积核元素并构建二维列表
    kernel = []
    for r in range(kernel_size):
        row_data = [int(x) for x in raw_input[ptr : ptr + kernel_size]]
        kernel.append(row_data)
        ptr += kernel_size

    # 5. 读取卷积参数：步长、填充、膨胀率
    stride = int(raw_input[ptr])
    padding = int(raw_input[ptr + 1])
    dilation = int(raw_input[ptr + 2])

    # 6. 计算有效核尺寸（膨胀后的覆盖范围）
    effective_k = kernel_size + (kernel_size - 1) * (dilation - 1)

    # 7. 计算输出特征图的尺寸
    out_h = (height + 2 * padding - effective_k) // stride + 1
    out_w = (width + 2 * padding - effective_k) // stride + 1

    # 初始化输出结果矩阵
    output_map = [[0] * out_w for _ in range(out_h)]

    # 8. 模拟卷积过程：遍历输出图的每一个像素位置
    for i in range(out_h):
        for j in range(out_w):
            total_sum = 0
            # 计算当前滑动窗口在填充后矩阵中的起始坐标
            start_x = i * stride
            start_y = j * stride

            # 遍历原始卷积核的每一个元素
            for kr in range(kernel_size):
                for kc in range(kernel_size):
                    # 根据膨胀率计算其在填充后特征图中对应的坐标
                    # 这里减去 padding 是为了直接在原 feature_map 中查找，避免显式构建补零矩阵
                    actual_x = start_x + kr * dilation - padding
                    actual_y = start_y + kc * dilation - padding

                    # 检查坐标是否在原始输入特征图范围内
                    if 0 <= actual_x < height and 0 <= actual_y < width:
                        val = feature_map[actual_x][actual_y]
                        total_sum += val * kernel[kr][kc]

            output_map[i][j] = total_sum

    # 9. 按照格式打印输出结果
    for row in output_map:
        print(" ".join(map(str, row)))
if __name__ == "__main__":
    perform_dilated_convolution()