2025级新生第二轮周赛
7-1 明明的随机数
题目理解
输入：生成 N 个范围在 1 到 1000 之间的随机整数（N≤100），其中可能存在重复的数字。
处理逻辑：
去重：对于重复的数字，只保留一个，去除其余相同的数。
排序：将去重后的数字按从小到大的顺序排列。
输出：
第一行输出 M（去重后不同数字的个数）。
第二行输出 M 个从小到大排序后的不同数字。
简单来说，就是对一组可能包含重复的整数，先去除重复项，再对剩余的不同数字进行升序排序，最后输出结果的数量和具体数值。
#include<bits/stdc++.h>
using namespace std;
int main(){
set<int> s; // 定义set容器，自动去重且元素按升序排列
int n;
cin >> n; // 读取输入的整数个数n
for(int i = 0;i < n;i++){
int x;
cin >> x; // 读取每个整数
s.insert(x); // 插入set，自动去重（重复元素不会被插入）
}
cout << s.size() << '\n'; // 输出去重后的元素个数
// 按升序输出所有元素，确保元素间用空格分隔，最后无多余空格
int f = 0; // 标记是否为第一个元素
for(auto it:s){ // 遍历set中的元素（已自动排序）
if(!f) { // 第一个元素直接输出，不加分隔符
cout << it;
f = 1; // 标记已输出第一个元素
}
else { // 非第一个元素，先输出空格再输出元素
cout << " " << it;
}
}
}
7-2 考试座位号
题目理解
输入：
首先输入考生数量 N（≤1000），然后输入 N 行考生信息，每行包含 “准考证号（16 位数字） 试机座位号 考试座位号”。
接着输入查询次数 M（≤N），再输入 M 个待查询的试机座位号。
处理逻辑：需要建立 “试机座位号” 到 “准考证号” 和 “考试座位号” 的映射关系，以便快速响应查询。
输出：对于每个待查询的试机座位号，输出对应的考生准考证号和考试座位号，两者用一个空格分隔。
简单来说，就是要实现一个基于 “试机座位号” 的信息检索系统，快速匹配并输出考生的准考证号和考试座位号。
#include<bits/stdc++.h>
using namespace std;
// 用两个数组分别存储：
// x[b] = 试机座位号为b的考生的准考证号
string x[1004];
// y[b] = 试机座位号为b的考生的考试座位号
int y[1004];
int main(){
int n;
cin >> n; // 读取考生总人数n
// 循环读入每个考生的信息
for(int i = 0;i < n;i++){
string a; // 准考证号
int b,c; // b=试机座位号，c=考试座位号
cin >> a >> b >> c;
// 用试机座位号b作为下标，存储对应的准考证号和考试座位号
x[b] = a;
y[b] = c;
// 注释掉的结构体用法，与数组用法功能一致
// x[b].zkz = a,x[b].ks = c;
}
int m;
cin >> m; // 读取查询次数m
// 循环处理每个查询
for(int i = 0;i < m;i++){
int a; // 待查询的试机座位号
cin >> a;
// 直接通过试机座位号a作为下标，输出对应的准考证号和考试座位号
cout << x[a] << ' ' << y[a] << '\n';
// 注释掉的结构体输出方式
// cout << x[a].zkz << ' ' << x[a].ks << '\n';
}
}
7-3 帅到没朋友
题目理解
输入：
首先给出朋友圈的个数 N（≤100）；
然后 N 行，每行先给出一个朋友圈的人数 K（≤1000），接着列出该朋友圈内所有人的 5 位 ID（从 00000 到 99999）；
再给出待查询的人数 M（≤10000），随后一行列出 M 个待查询的 ID。 判断规则：“帅到没朋友的人” 有两种情况：
根本没出现在任何朋友圈里；
出现在某个朋友圈里，但该朋友圈只有自己一个人（即 K=1）。
输出：按查询顺序输出所有 “帅到没朋友的人” 的 ID，ID 间用一个空格分隔，行首尾无多余空格；如果没有人符合条件，输出 No one is handsome。
简单来说，就是要从查询的 ID 中，筛选出那些 “不在任何朋友圈” 或 “仅在只有自己的朋友圈” 的人，并按查询顺序去重后输出。
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n; // 读取朋友圈的个数n
// 哈希表p用于标记"有朋友的人"：键为ID，值为1表示该ID有朋友
unordered_map<string,int> p;
// 遍历每个朋友圈
for(int i = 0;i < n;i++){
int k;
cin >> k; // 读取当前朋友圈的人数k
for(int j = 0;j < k;j++){
string b;
cin >> b; // 读取朋友圈中每个人的ID
// 只有当朋友圈人数>1时，才标记该ID"有朋友"（排除k=1的情况）
if(k != 1) p[b] = 1;
}
}
int m;
cin >> m; // 读取待查询的人数m
int f = 0; // 标记是否已有输出（用于控制空格）
// 遍历每个待查询的ID
for(int i = 0;i < m;i++){
string b;
cin >> b; // 读取查询的ID
// 若该ID不在p中（即"没朋友"）
if(p.count(b) == 0) {
// 第一次输出直接打印ID，后续输出前加空格
if(!f) {
f = 1;
cout << b;
} else {
cout << ' ' << b;
}
// 标记该ID已输出（避免重复输出同一个ID）
p[b] = 2;
}
}
// 若没有符合条件的ID，输出提示信息
if(!f){
cout << "No one is handsome" << '\n';
}
}
7-4 到底有多二
题目理解
基础定义：“犯二程度” 是数字中包含2的个数与其位数的比值。 额外倍数：
如果数字是负数，程度增加0.5倍（即乘以1.5）；
如果数字是偶数，程度再增加1倍（即乘以2）。
输入输出： 输入一个不超过 50 位的整数N；
输出N的犯二程度，结果保留小数点后两位（以百分比形式呈现）。
简单来说，就是先统计数字中2的个数和总位数，再结合 “负数”“偶数” 两个条件计算倍数，最终得到犯二程度的百分比。
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s; // 读取输入的整数（以字符串形式处理，支持大数字）
float a = 0; // 统计数字中'2'的出现次数
int l = s.size(); // 记录字符串长度（包含符号位）
// 遍历字符串，统计'2'的个数
for(int i = 0;i < l;i++){
if(s[i] == '2') a=a+1;
}
float bs = 1; // 倍数因子，初始为1
// 如果是负数（首位为'-'），倍数乘以1.5，且有效数字位数减1（排除符号位）
if(s[0] == '-') bs*=1.5,l--;
// 如果是偶数（最后一位数字为偶数），倍数再乘以2
if((s[s.size()-1]-'0')%2 == 0) bs*=2.0;
// 计算犯二程度：(2的个数 / 有效位数) * 倍数 * 100%
float ans = a/(l*1.0);
printf("%.2f",ans*bs*100); // 保留两位小数输出百分比数值
cout << '%'; // 输出百分号
}
7-5 谁先倒
题目理解
划拳规则：两人各自喊一个数字、划一个数字。若某人划出的数字等于两人喊出数字之和，则该人输，需喝一杯酒。两人同赢或同输则继续，直到出现唯一输家。
输入：
第一行是甲、乙的酒量（最多能喝的杯数，非负整数）。
第二行是划拳轮数N，随后N行是每轮划拳记录，格式为 “甲喊 甲划 乙喊 乙划”。
输出：
第一行输出先倒下的人（A代表甲，B代表乙）。
第二行输出未倒下的人喝的杯数。
一旦有人酒量耗尽（喝的杯数超过其酒量），程序终止，后续数据无需处理。
简单来说，就是模拟划拳过程，统计两人的喝酒杯数，判断谁先超出酒量，从而确定先倒下的人及另一人的喝酒数。
#include<bits/stdc++.h>
using namespace std;
int main(){
int a1,a2;
cin >> a1 >> a2; // 输入甲、乙的酒量（最多能喝的杯数）
int ans1 = 0,ans2 = 0; // 记录甲、乙当前喝的杯数
int n;
cin >> n; // 输入划拳轮数
for(int i = 0;i < n;i++){
// 读取本轮数据：甲喊x2、甲划x1；乙喊y2、乙划y1
int x1,x2,y1,y2;
cin >> x2 >> x1 >> y2 >> y1;
// f1标记甲是否输（1表示输，0表示赢），f2标记乙是否输
int f1 = 0,f2 = 0;
// 若甲划的数等于两人喊的数之和，甲输
if(x1 == x2 + y2){
f1 = 1;
}
// 若乙划的数等于两人喊的数之和，乙输
if(y1 == x2 + y2){
f2 = 1;
}
// 只有一人输时，对应人喝酒杯数+1
if(f1 && !f2){ // 甲输乙赢，甲喝酒
ans1++;
}
if(!f1 && f2){ // 乙输甲赢，乙喝酒
ans2++;
}
// 若有人喝的杯数超过酒量（达到酒量+1），终止循环
if(ans1 == a1 + 1 || ans2 == a2 + 1){
break;
}
}
// 输出结果：先倒下的人及另一人喝的杯数
if(ans1 == a1 + 1){ // 甲先倒下
cout << 'A' << '\n' << ans2;
} else if(ans2 == a2 + 1){ // 乙先倒下
cout << 'B' << '\n' << ans1;
}
}
7-6 Legs
题目理解
场景：农场里只有鸡（2 条腿）和牛（4 条腿），已知总腿数 n，要求计算最少的动物总数。
思路：要使动物总数最少，应尽可能多的养腿数多的动物（即牛）。因此，先尽可能多的计算牛的数量，剩余的腿数用鸡来补充。
输入输出：
输入：测试用例数 t，每个测试用例给出总腿数 n（n 是偶数）。
输出：每个测试用例对应的最少动物总数。
简单来说，就是通过 “优先养牛，剩余腿数养鸡” 的策略，计算满足总腿数 n 的最少动物数量。
#include<bits/stdc++.h>
using namespace std;
int main(){
int T;
cin >> T; // 读取测试用例数量T
while(T--){ // 循环处理每个测试用例
int n;
cin >> n; // 读取总腿数n（题目保证n是偶数）
// 计算最少动物总数：
// 1. n/4：尽可能多的牛（每头牛4条腿）的数量
// 2. (n%4>0)：若剩余腿数>0（只能是2条，因n是偶数），需加1只鸡
cout << n/4 + (n%4 > 0) << '\n';
}
}
7-7 Beautiful Year
题目注释
输入：一个年份 y（范围是 1000 ≤ y ≤ 9000）。
输出：严格大于 y 的最小的、所有数字互不重复的年份。
例如，给定 y=1987，下一个满足条件的年份是 2013（因为 1988 及之后的年份存在重复数字，直到 2013 所有数字才互不相同）。
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n; // 读取输入的年份n
// 从n+1开始逐个检查年份，直到找到符合条件的年份
for(int i = n+1;;i++){
map<int,int> p; // 用map存储年份中出现的数字（自动去重）
int t = i; // 临时变量t用于分解年份的每一位数字
// 分解年份的每一位数字，存入map
while(t){
p[t%10] = 1; // 取t的最后一位数字，存入map（键为数字，值无实际意义）
t /= 10; // 移除t的最后一位数字
}
// 若map的大小为4，说明年份的4个数字互不重复
if(p.size() == 4) {
cout << i << '\n'; // 输出该年份
break; // 找到后退出循环
}
}
}
7-8 Primary Task
题目理解
关键规则：“重要整数” 原本是10^x （比如 10^5是 100000），但被误写成了将指数直接拼接在 “10” 后的形式（比如10^5误写成 105,10^19误写成 1019）。
输出：对于每个a，如果它可以是某个10^x（x≥2）的误写形式，输出 “YES”，否则输出 “NO”。
简单来说，就是要检查每个输入的整数是否能拆分为 “10” + “一个不小于 2 的整数” 的形式，且原形式 10^x是合法的（即x≥2）。
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n; // 读取测试用例数量n
for(int i = 0;i < n;i++){
string s;
cin >> s; // 读取待判断的整数（以字符串形式处理，方便拆分）
// 若数字长度小于3，不可能拆成"10"+"x"（x≥2），直接输出NO
if(s.size() < 3) {
cout << "NO" << '\n';
continue;
}
int f = 0; // 标记前两位是否为"10"
// 检查前两位数字是否组成10（s[0]是第一位，s[1]是第二位）
if((s[0]-'0')*10 + (s[1]-'0') == 10) {
f = 1; // 前两位是10，标记为1
}
// 若前两位是10，且第三位及以后组成的数字≥2（排除"101"这种x=1的情况）
if(f && (s[2] >= '1' && s != "101")) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
}
7-9 找筷子
题目理解
场景：一堆筷子中，只有一只筷子是落单的（出现一次），其余筷子都成双（出现两次）。
输入：
第一行是筷子的数量 n（n 为奇数）。
第二行是 n 个整数，表示每根筷子的长度 a[i]。
输出：落单筷子的长度。
简单来说，就是要从一组数中，找出唯一出现一次的那个数（其余数都出现两次）。
#include<bits/stdc++.h>
using namespace std;
signed main(){
ios::sync_with_stdio(0); // 关闭输入输出同步，加速读写
cin.tie(0),cout.tie(0); // 解除cin与cout的绑定，进一步加速
int n;
cin >> n; // 读取筷子的数量n（n为奇数）
int sum = 0; // 用于存储异或运算的结果
// 遍历每根筷子的长度
for(int i = 0;i < n;i++){
int x;
cin >> x; // 读取当前筷子的长度
sum ^= x; // 关键：用异或运算累计结果
}
// 最终sum即为落单筷子的长度
cout << sum << '\n';
}
7-10 篮子里的甜甜圈
题目理解
场景：篮子里有甜甜圈，店主会进行 “放入”（操作 1）、“取出”（操作 2）甜甜圈的操作；流浪汉会在操作 3 时拿走当前篮子里质量最大的甜甜圈。
输入：
第一行是初始甜甜圈数量 n 和操作数量 q（均≤2×10⁵）。
第二行是 n 个初始甜甜圈的质量 w[i]（≤10⁹）。
接下来 q 行是操作：
操作 1：放入一个质量为 w 的甜甜圈；
操作 2：取出一个质量为 w 的甜甜圈（保证该甜甜圈存在）；
操作 3：流浪汉拿走当前最大质量的甜甜圈，需输出该质量，并累计总偷取质量。
输出：
每次操作 3 时输出流浪汉拿走的甜甜圈质量；
所有操作结束后输出流浪汉总共偷取的质量。
简单来说，就是要维护一个 “动态的最大质量集合”，支持快速的 “插入”“删除”“取最大值” 操作，并统计取最大值的总质量。
#include<bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false); // 关闭输入输出同步，加速读写
cin.tie(nullptr); // 解除cin与cout绑定，进一步优化速度
int n, q;
cin >> n >> q; // 读取初始甜甜圈数量n和操作数量q
priority_queue<int> pq; // 大根堆，用于快速获取当前最大质量的甜甜圈
unordered_map<int, int> cnt; // 哈希表，记录每种质量的甜甜圈实际数量（解决堆中冗余元素问题）
// 初始化：加入初始甜甜圈
for (int i = 0; i < n; ++i) {
int w;
cin >> w;
pq.push(w); // 放入堆中
cnt[w]++; // 计数+1
}
long long sum = 0; // 记录流浪汉偷取的总质量
// 处理每一个操作
while (q--) {
int op;
cin >> op;
if (op == 1) { // 操作1：放入一个质量为w的甜甜圈
int w;
cin >> w;
pq.push(w); // 加入堆
cnt[w]++; // 计数+1
}
else if (op == 2) { // 操作2：取出一个质量为w的甜甜圈
int w;
cin >> w;
cnt[w]--; // 计数-1（不直接操作堆，避免堆结构破坏）
}
else if (op == 3) { // 操作3：流浪汉拿走当前最大质量的甜甜圈
// 清除堆中"已被取完"的冗余元素（计数为0的质量）
while (!pq.empty() && cnt[pq.top()] == 0) {
pq.pop();
}
// 取出当前最大质量的甜甜圈
if (!pq.empty()) {
int ma = pq.top(); // 获取最大值
pq.pop(); // 从堆中移除
cnt[ma]--; // 计数-1
sum += ma; // 累加偷取总质量
cout << ma << '\n'; // 输出本次偷取的质量
}
}
}
cout << sum << '\n'; // 输出偷取的总质量
return 0;
}
7-11 互评成绩
题目理解
评分规则：每个学生的作业会被 k 个同学评审，得到 k 个成绩。需要去掉一个最高分和一个最低分，将剩余分数取平均，作为该学生的最终成绩。
输入： 第一行给出三个正整数 N（学生总数，3 < N ≤ 10⁴）、k（每份作业的评审数，3 ≤ k ≤ 10）、M（需要输出的学生数，≤20）。
随后 N 行，每行给出 k 个评审成绩（范围 [0, 100]）。
输出：
按非递减顺序输出最后得分最高的 M 个成绩，保留小数点后 3 位，分数间用一个空格分隔，行首尾无多余空格。
简单来说，就是对每个学生的 k 个成绩进行 “去最高、去最低、求平均” 的计算，然后将所有学生的最终成绩排序，输出前 M 个最高的成绩。
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,k,m;
cin >> n >> k >> m; // 读取学生总数n、每份作业的评审数k、需输出的学生数m
float a[n+1]; // 存储每个学生的最终成绩
// 计算每个学生的最终成绩
for(int i = 0;i < n;i++){
deque<int> d; // 用双端队列存储当前学生的k个评审成绩
for(int j = 0;j < k;j++){
int x;
cin >> x; // 读取一个评审成绩
d.push_back(x); // 加入队列
}
sort(d.begin(),d.end()); // 对成绩排序（从小到大）
d.pop_back(); // 去掉最高分（队尾元素）
d.pop_front(); // 去掉最低分（队头元素）
// 计算剩余k-2个成绩的总和
int sum = 0;
for(int j = 0;j < k-2;j++){
sum += d[j];
}
// 计算平均分作为最终成绩（转换为浮点数除法）
a[i] = sum / ((k-2)*1.0);
}
sort(a,a+n); // 对所有学生的最终成绩从小到大排序
// 输出得分最高的m个成绩（即排序后的最后m个元素）
int f = 0; // 标记是否为第一个输出，控制空格
for(int i = n-m;i < n;i++){
if(!f){ // 第一个元素直接输出，不加分隔符
f = 1;
printf("%.3f",a[i]); // 保留3位小数
} else { // 后续元素前加空格
cout << ' ';
printf("%.3f",a[i]);
}
}
}
7-12 彩虹瓶
题目理解
装填规则：需要按顺序（1 到 N）装填颜色。工人从工厂按发货顺序搬箱子，若当前箱子是待装填的颜色则直接装填；否则堆到临时货架上。装填完一种颜色后，检查货架顶端是否是下一个待装填颜色，若是则取下装填，否则继续从工厂搬箱。同时货架容量有限，若堆积超过容量则无法完成。
输入：
第一行给出三个正整数 N（颜色数量，1 < N ≤ 10³）、M（临时货架容量，M < N）、K（发货顺序数量）。
随后 K 行，每行是 1 到 N 的一个排列，表示工厂的发货顺序。
输出：
对每个发货顺序，判断工人是否能顺利完成装填，能则输出 “YES”，否则输出 “NO”。
简单来说，就是模拟装填过程，检查是否能按顺序 1 到 N 完成装填，且货架堆积量不超过容量M。
#include<bits/stdc++.h>
using namespace std;
int main(){
int n, m, k;
cin >> n >> m >> k; // 输入颜色总数n、货架容量m、发货顺序数量k
// 遍历每个发货顺序
for(int i = 0; i < k; i++){
int a[n+1]; // 存储当前发货顺序的颜色序列
for(int j = 0; j < n; j++){
cin >> a[j]; // 读取该发货顺序的每个颜色
}
stack<int> s; // 用栈模拟临时货架
int cnt = 1; // 当前需要装填的目标颜色（从1开始，按顺序递增）
// 按发货顺序处理每个颜色箱子
for(int j = 0; j < n; j++){
s.push(a[j]); // 将当前箱子堆到货架上
// 检查货架顶端是否是当前需要的颜色，若是则持续装填
while(!s.empty() && s.top() == cnt){
cnt++; // 目标颜色更新为下一个
s.pop(); // 从货架取下并装填
}
// 若货架堆积量超过容量m，提前终止处理（无法完成）
if(s.size() > m) break;
}
// 判断是否成功完成：货架为空且所有颜色（1~n）都已按顺序装填
if(s.empty() && cnt == n + 1){
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
}
}
投递京东等公司10个岗位
查看10道真题和解析
