✅ 春招备战指南 ✅

💡 学习建议：

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

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

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

🤖 内容包含AI辅助生成，题解和代码均经过多轮验证，有问题欢迎评论

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

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

团子-2026.04.18-研发岗

1. 小兰的批量清洗保留表

问题描述

小兰在整理一张长度为 的记录表，表中的第 项权值为 。

他会连续进行 轮清洗。每一轮都执行下面的规则：

• 删除当前表中权值最小的一项；
• 如果最小值出现了多次，就删掉其中位置最靠前的那一项。

清洗结束后，剩余记录的相对顺序保持不变。请输出最后留下来的序列。

输入格式

每个测试文件包含多组数据。

第一行输入一个整数 ，表示测试数据组数。

对于每组数据：

• 第一行输入两个整数 ；
• 第二行输入 个整数 。

输出格式

对于每组数据，输出一行，表示完成 轮清洗后的序列。

剩余元素之间用一个空格分隔。

样例输入

3
5 2
3 1 4 1 5
3 0
1 2 3
5 4
5 4 3 2 1

样例输出

3 4 5
1 2 3
5

样例说明

• 第一组里，两个最小值都是 ，要先删位置更靠前的那个，再删另一个 ，最后剩下 3 4 5。
• 第二组不需要清洗，原序列直接保留。
• 第三组删掉前四轮最小值后，只剩下最大的 5。

数据范围

• 
• 
• 
• 
• 单个测试文件中所有 的总和不超过

题解

每一轮删掉的其实就是当前还没被删掉的最小二元组 。

这里的真正要抓的是：

• 比较优先级先看值 ；
• 值相同的时候再看下标 ，下标小的会更早被删。

所以完全没必要真的删 次。把所有位置写成二元组 后整体排一次序，排在最前面的 个位置，就是最终会被删掉的那 项。

拿到这 个下标以后，再按原顺序扫一遍数组，把没被标记的位置输出出来即可。

复杂度分析

• 排序复杂度是 。
• 标记和输出都是线性复杂度。
• 因此单组总复杂度为 ，可以通过数据范围。

参考代码（Python）

import sys

def input() -> str:
    return sys.stdin.readline().strip()

def solve() -> None:
    t = int(input())
    out = []

    for _ in range(t):
        n, m = map(int, input().split())
        arr = list(map(int, input().split()))

        # 把每个元素写成 (值, 原下标)。
        # 排序后最前面的 m 个位置，就是最终会被清洗掉的记录。
        ords = [(arr[i], i) for i in range(n)]
        ords.sort()

        removed = [False] * n
        for k in range(m):
            removed[ords[k][1]] = True

        # 剩余元素的相对顺序不变，按原数组顺序输出即可。
        cur = []
        for i, x in enumerate(arr):
            if not removed[i]:
                cur.append(str(x))
        out.append(" ".join(cur))

    print("\n".join(out))

if __name__ == "__main__":
    solve()

2. 小兰的半径覆盖表

问题描述

平面上有 个整点，编号为 。

对任意两个不同的编号 ，以点 为支点，把线段 绕着点 旋转一整圈。这样扫过的区域，正好是一个以点 为圆心、以点 到点 的距离为半径的闭圆盘。

记 为这个圆盘里包含的其他点数，要求：

• 点 自己不计入；
• 点 也不计入；
• 其余编号不同的点，只要落在这个圆盘内就计入答案；
• 特别地，。

请输出整个 的答案矩阵。

输入格式

每个测试文件包含多组数据。

第一行输入一个整数 ，表示测试数据组数。

对于每组数据：

• 第一行输入一个整数 ，表示点的数量；
• 接下来 行，每行输入两个整数 ，表示一个点的坐标。

输出格式

对于每组数据输出 行。

第 行输出 个整数，依次表示 。

样例输入

2
3
1 1
2 1
1 2
4
1 1
2 1
3 1
4 1

样例输出

0 1 1
0 0 1
0 1 0
0 0 1 2
1 0 1 2
2 1 0 1
2 1 0 0

数据范围

• 
• 
• 
• 单个测试文件中所有 的总和不超过

样例说明

样例	解释说明
第 组	以点 为圆心时，点 和点 到圆心的距离都等于 。所以无论半径取到点 还是点 ，另一个点也会被圈进去，答案都是 。
第 组	四个点都在一条直线上。以最左侧点为圆心时，半径越大，能覆盖到的其他点数也越多，因此最后一个位置会得到 。

题解

固定某个圆心 来看。

如果把其他点到点 的距离从小到大排好，那么对于某个点 ：

• 所有距离严格小于 的点，一定都在圆盘里；
• 距离恰好等于 的点，也都在圆盘边界上，同样要计入。

所以， 实际上等于：

• “距离不超过点 的那些点” 的总数量，
• 再减去点 自己这一个。

这就变成了一道排序题。

对每个圆心 ：

1. 枚举所有 ，计算平方距离 ；
2. 按平方距离升序排序；
3. 对于排序后的每一段“距离相同”的连续块，设它的右端点下标是 ；
4. 这个块里的任意一个点，答案都等于 。

这里使用的是从 开始的下标。因为到位置 为止一共有 个点，去掉当前这个点自己，剩下的就是 个点。

总共有 行，每一行都需要排一次长度为 的数组，所以总时间复杂度是 ，空间复杂度是 。

参考代码（Python）

import sys

def input() -> str:
    return sys.stdin.readline().strip()

def solve() -> None:
    t = int(input())
    out = []

    for _ in range(t):
        n = int(input())
        pts = [tuple(map(int, input().split())) for _ in range(n)]

        for i in range(n):
            cx, cy = pts[i]
            dist = []
            for j in range(n):
                if i == j:
                    continue
                dx = pts[j][0] - cx
                dy = pts[j][1] - cy
                # 只需要比较远近，保存平方距离就够了，还能避免开根号。
                dist.append((dx * dx + dy * dy, j))

            # 把其他点按“离当前圆心有多远”排序。
            dist.sort()
            row = [0] * n

            m = len(dist)
            l = 0
            while l < m:
                r = l
                while r + 1 < m and dist[r + 1][0] == dist[l][0]:
                    r += 1
                # 同一段等距离块里的点，能覆盖到的其他点数完全相同。
                for k in range(l, r + 1):
                    row[dist[k][1]] = r
                l = r + 1

            # row[j] 就是以点 i 为圆心、半径取