2026团体程序设计天梯赛L1-L2题解（C++）

Spike_Q

1262人浏览 · 2026-04-23 21:12:21

Spike_Q · 2026-04-23 21:12:21 发布

L1-1 一行代码

每次一行代码，建起我们的未来 —— 本题非常简单，就请你直接在屏幕上输出这句话：“Building the Future, One Line of Code at a Time.”。

输入格式：

本题没有输入。

输出格式：

在一行中输出 Building the Future, One Line of Code at a Time.。

输入样例：

无

输出样例：

Building the Future, One Line of Code at a Time.

代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    cout<<"Building the Future, One Line of Code at a Time.";
}

L1-2 要刷多少题

老师说：想在天梯赛取得好成绩，第一件事是把前面 n 年的天梯赛真题做一遍。
已知每年的天梯赛有 15 道题目，全新不重复。请你算一下，一共要刷多少道真题？

输入格式：

输入第一行给出一个正整数 n（≤10），为题面中所述老师提出的比赛年数。

输出格式：

在一行中输出学生需要做完的题目总数。

输入样例：

输出样例：

代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    int n;
    cin>>n;
    cout<<15*n;
}

L1-3 就挺突然的

上面是新浪微博上的一张图，内容是“蹲厕所时突然想到，2026 年出生的孩子，能活到 3001 年”，就，挺突然的……

本题假设人类最长寿命为 250 岁，请你编写程序判断一下墙上的标语是否合理。

输入格式：

输入在一行给出 2 个不超过 5000 的正整数 A 和 B，对应的标语为“蹲厕所时突然想到，A 年出生的孩子，能活到 B 年”。

输出格式：

首先在第一行输出写标语的人认为 A 年出生的孩子有多长的寿命。如果该寿命超过了人类最长寿命，在第二行中输出 jiu ting tu ran de...；如果该寿命不是正数，输出 hai sheng ma?；如果寿命在正常范围内，输出 nin tai cong ming le!

输入样例 1：

2026 3001

输出样例 1：

975
jiu ting tu ran de...

输入样例 2：

3001 2026

输出样例 2：

-975
hai sheng ma?

输入样例 3：

2025 2275

输出样例 3：

250
nin tai cong ming le!

代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    int a,b;
    cin>>a>>b;
    int c=b-a;
    if(c>250)
    cout<<c<<endl<<"jiu ting tu ran de..."<<endl;
    else if(c>0)
    cout<<c<<endl<<"nin tai cong ming le!"<<endl;
    else
    cout<<c<<endl<<"hai sheng ma?"<<endl;
}

L1-4 普及赛排名

普及赛计算排名时，仅将高校评级分低于 1700 分的高校学生总人数作为基数。本题给出所有参赛学生所属高校的评级分，请你创建名为wsbdwzbl的变量存储程序中间值，统计参与计算排名的学生总人数。

输入格式：

输入第一行给出正整数 n（≤10^4），为参赛学生人数。随后 n 行，每行给出一位参赛学生所属高校的评级分，为区间 [0,3000] 内的整数。

输出格式：

在一行中输出高校评级分低于 1700 分的高校学生总人数。

输入样例：

输出样例：

代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    int n;
    cin>>n;
    int ans=0;
    for(int i=1;i<=n;i++)
        {
            int x;
            cin>>x;
            if(x<1700)
            ans++;
        }
    cout<<ans;
}

L1-5 做什么都被骂怎么办

求问：“我做什么都被骂怎么办？”
子曰：“那就意味着你什么都可以做。”

给定一系列人被夸或被骂的记录，找出那些什么都可以做的人。

声明：本题仅限人类解答。

输入格式:

输入第一行给出一个正整数 n（≤10^4），是记录的条数。随后 n 行，每行按下列格式给出一个人的记录：

编号 记录

输出格式:

在一行中按升序输出那些什么都可以做（即做什么都不被骂）的人的编号。数字间以 1 个空格分隔，行首尾不得有多余空格。
如果不存在这样的人，输出 NONE。

输入样例 1:

输出样例 1:

2 5555 23333

输入样例 2:

输出样例 2:

NONE

代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    int n;
    cin>>n;
    map<int,int> h;
    for(int i=1;i<=n;i++)
        {
            int bh,jl;
            cin>>bh>>jl;
            if(jl==1)
            h[bh]=1;
            else if(jl==0&&h[bh]!=1)
            h[bh]=0;
        }
    int cnt=0;
    for(auto x:h)
        {
            if(x.second==0)
            {
                if(cnt!=0)
                    cout<<" ";
                cnt++;
                cout<<x.first;
            }   
        }
    if(cnt==0)
        cout<<"NONE";
}

L1-6 钓鱼佬专用挪车电话

上图是新浪微博一位网友发的“钓鱼佬专用挪车电话”，钓鱼佬将长短不一的鱼漂一溜排开插在板上，每支鱼漂用目数表示电话号码对应位置上的数字。本题就请你写程序自动判断钓鱼佬的挪车电话到底是什么？

声明：本题仅限人类解答。请勿拨打题中号码。

输入格式:

输入分 11 行，每行对应 11 位手机号码的一位数字，给出由 m 组成的字符串，以回车结束。每个 m 代表鱼漂上的一目，一行中有多少 m 就表示这一位数字是多少，空行代表 0。题目保证每行都不超过 9 个 m。

输出格式:

在一行中输出钓鱼佬的手机号。

输入样例:

m
mm
mmmmmmmm
mmm
m
mm
m
mmmmmmmm

mmmmmmmm
mm

输出样例:

12831218082

代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    string ans="";
    for(int i=1;i<=11;i++)
        {
            string s;
            getline(cin,s);
            int t=s.size();
            ans+=to_string(t);
        }
    cout<<ans;
}

L1-7 网络流量监测

网安工程师需要分析服务器日志中的网络流量数据，找出潜在的攻击行为。本题就请你编写程序，分析给定时间段内的网络流量数据，找出流量最大值、最小值、平均值和中值，并且标出超过平均值 2 倍的疑似攻击点。

声明：本题仅限人类解答。

输入格式：

输入第一行给出正整数 n（≤10^3），为流量数据的总条数。第二行给出 n 个不超过 10^6 的非负整数，依次对应每小时记录的进入流量（以 MB 为单位）。

输出格式：

输出第一行依次给出流量的最大值、最小值、平均值（向下取整）和中值。第二行升序输出所有疑似攻击点的小时数（从 1 到 n）。如果没有疑似攻击点，则输出 Normal。

同行数据间以 1 个空格分隔，行首尾不得有多余空格。

输入样例 1：

10
150 180 200 120 5000 136 115 131 4700 239

输出样例 1：

5000 115 1097
5 9

输入样例 2：

10
150 180 200 120 50 136 115 131 47 239

输出样例 2：

239 47 136
Normal

代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    int n;
    cin>>n;
    int mmax=0,mmin=1e7,sum=0;
    vector<int> a(n);
    for(int i=0;i<n;i++)
        {
            cin>>a[i];
            mmax=max(mmax,a[i]);
            mmin=min(mmin,a[i]);
            sum+=a[i];
        }
    int pj=floor(sum*1.0/n);
    cout<<mmax<<" "<<mmin<<" "<<pj<<endl;
    vector<int> ans;
    for(int i=0;i<n;i++)
        {
            if(a[i]>pj*2)
            ans.push_back(i+1);
        }
    if((int)ans.size()!=0)
    {
        int o=0;
        for(auto x:ans)
            {
            if(o!=0)
            cout<<" ";
            o++;
            cout<<x;
            }
    }
    else
    cout<<"Normal";
}

L1-8 智慧文本编辑器

众所周知，随着基于大语言模型（LLM）的人工智能的大规模普及，现在越来越多的系统拥有了人工智能模块（当然，拼题 A 也有）。为了响应潮流，龙龙打算也做一个智慧文本编辑器，但因为大语言模型的 API 太贵了，龙龙打算让这个编辑器的“智慧”停留在名字上就好了。但功能还是得写的，具体来说，对于当前正在编辑的文档，这个编辑器应当支持以下三个功能：

查找指定字符串 s1 前 3 次出现的位置；
在指定位置 p 插入一个指定字符串 s2；
将某一段连续的字符串翻转。

真的文本编辑器可太复杂了，这里我们只简单化考虑由大小写英文字母和数字组成的字符串。

声明：本题仅限人类解答。

输入格式：

输入第一行是一个整数 N (1≤N≤50)，表示操作的数量。

第二行是一个字符串 S (1≤∣S∣≤10^3)，表示待操作的初始字符串。

接下来的 N 行，每行给出一条操作指令。根据操作种类，分别为以下格式：

1 s1：对应查找操作，查找字符串 s1 在当前字符串 T 中前 3 次出现的位置。
2 p s2：对应插入操作，将字符串 s2 插入到当前字符串 T 中“下标为 p 的字符”之前。当 p=∣T∣ 时，表示插入到字符串末尾。
3 l r：对应翻转操作，将当前字符串 T 中下标从 l 到 r 的连续子串翻转。

字符串下标从 0 开始。保证所有输入中的字符串都只包含大小写英文字母和数字，且满足：1≤∣s1∣≤5，1≤∣s2∣≤10。

对于第二类和第三类操作，保证输入下标合法，即第二类操作满足 0≤p≤∣T∣，第三类操作满足 0≤l≤r<∣T∣。

说明：对于任意字符串 X，∣X∣ 表示字符串 X 的长度。

输出格式：

对于第一类操作，按从小到大的顺序输出查找到的所有位置（即目标字符串的第一个字符在当前字符串中的下标），相邻两个位置之间用 1 个空格分隔。如果不足 3 次，就按实际查找到的次数输出；如果一次也没有找到，输出 -1。

注意：只要位置不同，就算是不同次出现，出现的字符串允许相互重叠。例如 ababa 中出现了 2 次 aba，位置依次为 0 和 2。

对于第二类和第三类操作，输出操作后的结果字符串。

输入样例：

10
ababa
1 a
1 aba
1 aca
2 0 X
2 6 Y
2 3 M
3 2 6
3 4 4
1 aa
3 0 7

输出样例：

0 2 4
0 2
-1
Xababa
XababaY
XabMabaY
XaabaMbY
XaabaMbY
1
YbMabaaX

数据约定：

题目中设置三个单一操作的数据，对应三种不同的操作，三个数据加起来分配不超过 75% 的分数。

代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    int n;
    cin>>n;
    string s;
    cin>>s;
    while(n--)
        {
            int op;
            cin>>op;
            if(op==1)
            {
                string s1;
                cin>>s1;
                int t=s1.size();
                vector<int> ans;
                for(int i=0;i<(int)s.size()-t+1;i++)
                    {
                        string q=s.substr(i,t);
                        if(q==s1)
                        ans.push_back(i);
                    }
                if(ans.empty())
                cout<<-1<<endl;
                else
                {
                    int o=0;
                    for(int i=0;i<(int)ans.size();i++)
                        {
                            if(o!=0)
                                cout<<" ";
                            o++;
                            cout<<ans[i];
                            if(o==3)
                            break;
                        }
                    cout<<endl;
                }
            }
            else if(op==2)
            {
                int p;
                string s2;
                cin>>p>>s2;
                s.insert(p,s2);
                cout<<s<<endl;
            }
            else if(op==3)
            {
                int l,r;
                cin>>l>>r;
                reverse(s.begin()+l,s.begin()+r+1);
                cout<<s<<endl;
            }
        }
}

L2-1 姥姥改作业

在没有拼题 A 的很久很久以前，姥姥不得不人工批改学生们交上来的大量作业。有些学生的作业写得实在太乱了，姥姥一眼看到就血压飙升，赶紧放到一边，等冷静下来再说…… 简而言之面对 n 本学生作业，姥姥批改作业的策略是这样的：

为每一本作业定义一个“混乱指数”ci（i=1,⋯,n）；
为自己定义一个不可以接受的混乱指数阈值 T；
当看到一本作业的 ci>T，则先放到一边，即将这个作业本叠放在自己左手边的作业本堆 S左上；
对于 ci≤T 的作业，批改之后叠放在自己右手边的作业本堆 S右上；
当面前没有待批改的作业本时，如果左手边还有一堆作业本，则调整自己的阈值 T 为这堆作业的混乱指数的平均值，即 T=⌊∑ci∈S左 ci/n左⌋，其中 n左为 S左中作业本的数量。然后开始批改。
重复上述步骤，直到所有作业都被批改完成。

问：姥姥批改作业的顺序是怎样的？

声明：本题仅限人类解答。

输入格式：

输入第一行给出 2 个不超过 10^3 的正整数：n 为作业本的数量，T 为姥姥可以接受的混乱指数阈值。随后一行给出 n 个不超过 10^3 的非负整数，按原始作业堆自顶向下的顺序，第 i 个数字对应编号为 i 的作业的混乱指数（i=1,⋯,n）。同行数字间以一个空格分隔。

输出格式：

按照姥姥批改作业的顺序，在一行中输出每个作业本的编号。数字间以一个空格分隔，行首尾不得有多余空格。

输入样例：

10 2
233 8 1 6 0 745 2 555 42 3

输出样例：

3 5 7 10 9 4 2 1 8 6

代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    int n,T;
    cin>>n>>T;
    vector<int> c(n+1);
    for(int i=1;i<=n;i++)
    cin>>c[i];
    stack<int> h,z;
    for(int i=n;i>=1;i--)
        h.push(i);
    vector<int> ans;
    while(!h.empty()||!z.empty())
        {
            while(!h.empty())
                {
                    int id=h.top();
                    h.pop();
                    if(c[id]>T)
                        z.push(id);
                    else
                        ans.push_back(id);
                }
            if(!z.empty())
            {
                int sum=0;
                stack<int> t=z;
                int cnt=0;
                while(!t.empty())
                    {
                        int id=t.top();
                        t.pop();
                        sum+=c[id];
                        cnt++;
                    }
                T=floor(sum*1.0/cnt);
                swap(h,z);
            }
        }
    int o=0;
    for(auto x:ans)
        {
            if(o!=0)
                cout<<" ";
            o++;
            cout<<x;
        }
}

L2-2 超参数搜索

神经网络模型的超参数是训练前需预先设定的参数，直接影响模型性能。在机器学习过程中需要对超参数进行优化，给学习器选择一组最优超参数，以提高学习的性能和效果。假设我们记录了一系列不同参数组合在验证集上的性能得分（如准确率），本题就请你找出性能得分最高的参数组合。更进一步，对于工程师提出的任一个目标性能得分 x，你也要从所有性能得分大于 x 的参数组合中，找到那个得分最小的组合。

声明：本题仅限人类解答。

输入格式：

输入第一行给出正整数 n（1<n≤10^5），为所有在验证集上跑过的参数组合的总量。于是我们将所有参数组合从 1 到 n 进行编号。第二行给出 n 个区间 [0,10^8] 内的整数，第 i 个数字表示编号为 i 的参数组合的性能得分。随后一行给出正整数 m（≤n/2），为工程师查询次数。接下来 m 行，每行给出一个查询的目标性能得分 x，同样在区间 [0,10^8] 内。

输出格式：

首先第一行按升序列出所有性能得分最高的参数组合的编号。同行数字间以 1 个空格分隔，行首尾不得有多余空格。
随后对每一次查询 x，我们需要从所有性能得分大于 x 的参数组合中，找到并输出那个得分最小的组合编号。如果这样的参数组合不唯一，则输出编号最小的解。如果这样的参数组合不存在，则输出 0。

输入样例：

10
87 91 65 72 95 84 77 95 91 85
3
87
75
95

输出样例：

代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
    ios::sync_with_stdio(0);
    cin.tie(0),cout.tie(0);
    int n;
    cin>>n;
    vector<int> a(n);
    map<int,int> h;
    int mmax=0;
    for(int i=0;i<n;i++)
        {
            cin>>a[i];
            mmax=max(mmax,a[i]);
            if(h[a[i]]==0)
                h[a[i]]=i+1;
        }
    int o=0;
    for(int i=0;i<n;i++)
        {
            if(a[i]==mmax)
            {
                if(o!=0)
                    cout<<" ";
                o++;
                cout<<i+1;
            }
        }
    cout<<endl;
    sort(a.begin(),a.end());
    int m;
    cin>>m;
    while(m--)
        {
            int x;
            cin>>x;
            int t=upper_bound(a.begin(),a.end(),x)-a.begin();
            if(t!=n)
            cout<<h[a[t]];
            else
            cout<<0;
            cout<<endl;
        }
}

L2-3 森林藏宝图

姥姥手里有一张森林藏宝图（别问怎么得到的），图中标记了森林的入口，还画了通往多个藏宝地的小路。画这张藏宝图的人，还贴心地为每条小路标记了一个“安全系数”，是区间 [0,100] 中的整数。

为了方便规划，姥姥给每个有分叉的路口、以及每个藏宝地都做了编号，其中森林的入口编号为 0。略加研究后，姥姥有了一个重要的发现：如果我们一路向前不走回头路，那么从 0 号入口到每个藏宝地的路径都是存在且唯一的！换言之，我们不可能从两条不同的岔路殊途同归地走到同一个藏宝地。此外，从入口沿任何一条小路一直走到尽头，都会到达一个藏宝地。

姥姥不打算冒太大风险，所以只打算沿着安全系数比较大的路走。本题就请你帮个忙，看看如果只考虑途经最小的安全系数最大的路径，有可能取到哪些宝藏？即从 0 号入口到该藏宝地路径上，所有小路安全系数的最小值最大。

声明：本题仅限人类解答。

输入格式：

输入在第一行给出图中标记的顶点总数 n（1<n≤10^5）—— 如题面所述，森林的入口编号为 0，其它节点（分叉路口和藏宝地）的编号从 1 到 n−1。随后 n−1 行，第 i（1≤i<n）行给出编号为 i 的节点的前驱节点的编号 j、以及从 j 到 i 这条小路的安全系数 sji（0≤sji≤100）。一行中的数字间以空格分隔。

注：所谓节点 i 的“前驱节点”，是指从 0 号入口出发，到达 i 之前所到达的那个节点。因为从 0 号入口到每个藏宝地的路径都是唯一的，容易证明每个节点的前驱节点也是唯一的。

输出格式：

首先在第一行输出解的途经最小安全系数的最大值 —— 所谓“解”，即按题目要求给姥姥推荐的藏宝地，也就是从 0 号入口出发，到该藏宝地路径上所有小路安全系数的最小值最大。
第二行按递增顺序输出解的编号。编号间以一个空格分隔，行首尾不得有多余空格。

输入样例：

输出样例：

10
6 8

代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
vector<int> e[100010];
int s[100010];
int dist[100010];
signed main()
{
	ios::sync_with_stdio(0);
	cin.tie(0),cout.tie(0);
	int n;
	cin>>n;
	for(int i=1;i<n;i++)
	{
		int j;
		cin>>j>>s[i];
		e[j].push_back(i);
	}
	dist[0]=1e18;
	stack<int> h;
	h.push(0);
	while(!h.empty())
	{
		int u=h.top();
		h.pop();
		for(auto v:e[u])
		{
			dist[v]=min(s[v],dist[u]);
			h.push(v);
		}
	}
	vector<int> yz;
	for(int i=0;i<n;i++)
	{
		if(e[i].empty())
		yz.push_back(i);
	}
	int mmax=0;
	for(auto x:yz)
	{
		if(dist[x]>mmax)
		mmax=dist[x];
	}
	vector<int> ans;
	for(auto x:yz)
	{
		if(dist[x]==mmax)
		ans.push_back(x);
	}
	sort(ans.begin(),ans.end());
	cout<<mmax<<endl;
	int o=0;
	for(auto x:ans)
	{
		if(o!=0)
		cout<<" ";
		o++;
		cout<<x;
	}
}

L2-4 大语言模型的推理

在新一代智能推理引擎中，一个大语言模型被设计为“逐步思考”的模式。它在回答复杂问题时，会从一个初始想法（称为“根思维节点”）出发，每一步都基于当前思路，生成若干个可能的下一步推理方向，每个方向代表一个子想法。我们考虑一个简化的推理策略：当有多个子想法可以继续时，模型选择推理概率最高的子想法尝试展开。如果最高概率有并列，则选择编号最小的子想法尝试展开。注意：模型不会重复思考同一个想法，以避免循环推理。所以严格说来，模型在选择下一步推理方向时，保证排除路径中已访问过的想法。一旦某个推理路径走到尽头（即没有新的子想法可生成），就结束本次推理。

本题就请你实现这个推理过程。声明：本题仅限人类解答。

输入格式：

输入第一行给出两个正整数：n（≤10^4）为模型中定义的想法的个数（于是所有的想法从 1 到 n 编号）；m（≤10n）为“思维跳跃”关系的数量。随后 m 行，每行描述一个“思维跳跃”关系，格式为：

id1 id2 p

表示从编号为 id1 的想法引出编号为 id2 的想法的概率等于 p%。题目保证 id1 和 id2 互不相等，均为合法编号，且任一对关系不会重复给出；p 是区间 [1, 100] 内的整数。注意：上述“引出”的关系并是单向的，即“A 引出 B”并不意味着 B 可以引出 A。
接下来一行给出正整数 K（≤100），后面跟着 K 个想法编号。

输出格式：

对于输入中给出的 K 个想法编号，顺序输出以每个想法为根思维节点的推理路径（包括根思维节点本身）。每个推理路径占一行，相邻想法编号的输出间以 -> 分隔，行首尾不得有多余空格。

输入样例：

10 18
2 3 1
2 1 3
2 6 3
6 2 3
3 1 4
1 6 5
6 1 2
1 4 5
1 5 4
4 5 1
5 6 3
5 7 4
7 4 7
7 8 1
8 9 8
9 7 9
9 5 9
3 8 6
5 2 3 10 6 7

输出样例：

2->1->4->5->7->8->9
3->8->9->5->7->4
10
6->2->1->4->5->7->8->9
7->4->5->6->2->1

代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 10010;
vector<pair<int,int>> e[N];
int v[N];
signed main()
{
	ios::sync_with_stdio(0);
	cin.tie(0),cout.tie(0);
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=m;i++)
	{
		int x,y,w;
		cin>>x>>y>>w;
		e[x].push_back({y,w});
	}
	int k;
	cin>>k;
	while(k--)
	{
		int s;
		cin>>s;
		vector<int> ans;
		memset(v,0,sizeof(v));
		v[s]=1;
		ans.push_back(s);
		while(1)
		{
			int mmax=-1;
			int next=-1;
			for(auto x:e[s])
			{
				int y=x.first;
				int w=x.second;
				if(v[y])
				continue;
				if(w>mmax||(w==mmax&&y<next))
				{
					mmax=w;
					next=y;
				}
			}
			if(next==-1)
				break;
			v[next]=1;
			s=next;
			ans.push_back(s);
		}
		for(int i=0;i<(int)ans.size();i++)
		{
			if(i!=(int)ans.size()-1)
				cout<<ans[i]<<"->";
			else
				cout<<ans[i]<<endl;
		}
	}
}