2023 PTA天梯赛补题（L1 & L2）

已于 2023-06-06 21:16:26 修改
阅读量2.9k 收藏 34
点赞数 4
分类专栏： 刷题记录 文章标签： c++ 算法 图论
于 2023-05-07 22:47:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50195602/article/details/130548255
版权

2023 天梯赛 L1 & L2 补题

L1

L1-089 最好的文档

输入输出题

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

int main()
{
    cout<<"Good code is its own best documentation.";
    return 0;
}

L1-090 什么是机器学习

输入输出题

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

int main()
{
    int a,b;
    cin>>a>>b;
    int c = a + b;
    cout<<c-16<<endl;
    cout<<c-3<<endl;
    cout<<c-1<<endl;
    cout<<c;
    return 0;
}

L1-091 程序员买包子

k == n 和 k == m 分别输出，题目怎么说就怎么做

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

int main()
{
    int n,m,k;
    string s;
    cin>>n>>s>>m>>k;
    if(k == n)
            cout<<"mei you mai "<<s<<" de";
    else if(k == m)
            cout<<"kan dao le mai "<<s<<" de";
    else
        cout<<"wang le zhao mai "<<s<<" de";
    return 0;
}

L1-092 进化论

判断一下c 等于a + b还是a*b或者都不是，分别按要求输出

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

int main()
{
    int n;
    cin>>n;
    for(int i = 1;i <= n;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        if(c == a + b) cout<<"Tu Dou";
        else if(c == a*b)cout<<"Lv Yan";
        else cout<<"zhe du shi sha ya!";
        if(i != n) cout<<endl;
        
    }
    return 0;
}

L1-093 猜帽子游戏

针对每一群玩游戏的宝宝，枚举判断一下就好了

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5;
int f[N];
int n;
int main()
{
    cin>>n;
    for(int i = 1;i <= n;i++)
        cin>>f[i];
    int t;
    cin>>t;
    for(int j = 1;j <= t;j++)
    {
        int cnt = 0;
        bool flag = true;
        for(int i = 1;i <= n;i++)
        {
            int x;cin>>x;
            if(x == 0) continue;
            if(x == f[i]) cnt++;
            else flag = false;
        }
        if(flag&&cnt) cout<<"Da Jiang!!!";
        else cout<<"Ai Ya";
        if(t != j) cout<<endl;
    }
    return 0;
}

L1-094 剪切粘贴

写的有点烦，基本就是一步一步模拟，思路在注释里写了

#include<bits/stdc++.h>
using namespace std;
int n;
int main()
{
    string s;
    cin>>s>>n;
    for(int i = 1;i <= n;i++)
    {
        int a,b;
        string s1,s2;
        cin>>a>>b>>s1>>s2;
        a -= 1; //保证下标从0开始
        b -= 1;
        //剪切
        string t = s.substr(a,b-a+1); //剪切出的字符串
        string sbe = s.substr(0,a); //t前面的字符串
        string saf = s.substr(b+1,s.size() - b - 1);//t后面的字符串
        s = sbe+saf; //剪切后的串
        //粘贴
        int len1 = s1.size();
        int len2 = s2.size();
        int st = -1;
        for(int j = 0;j + len1 - 1 < s.size();j++)
        {
            //查找开头与s1相同的串
            string temp = s.substr(j,len1);
            if(temp == s1)
            {
                st = j;//存下标
                //查看是否以s2结尾
                string af = s.substr(st+len1,len2);
                if(af == s2)
                {
                    //粘贴操作
                    string ss1 = s.substr(0,st+len1);
                    string ss2 = s.substr(st+len1,s.size());
                    s = ss1 + t + ss2;
                    break;
                }
                else{
                    st = -1;
                }
            }
        }
        //没有满足条件的粘贴位置，粘贴在最后
        if(st == -1)
            s = s + t;   
    }
    cout<<s;
    return 0;
}

L1-095 分寝室

枚举分配方案，代码中a代表女生寝室的数量，b为男生寝室的数量，如果存在寝室人数差值小于之前的最小值，则更新a，b，最后输出a和b即可

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int a,b;
int main()
{
    int n0,n1,n;
    cin>>n0>>n1>>n;
    int st = 1e9;
    for(int i = 1;i <= n-1;i++)
    {
        if((n0 % i == 0) && (n1 %(n-i) == 0))
        {
            int x = n0/i,y = n1/(n-i);
            if(x == 1 || y == 1) continue;
            if(abs(x-y) < st)
            {
                st = abs(x-y);
                a = i,b = n-i;
            }
        }
    }
    if(st != 1e9)
        cout<<a<<" "<<b;
    else
        cout<<"No Solution";
    return 0;
}

L1-096 谁管谁叫爹

模拟，要注意如果 NA正好是 SB的整数倍，则 A 是爹；如果 NB正好是 SA的整数倍，则 B 是爹；这里是NA是SB的整数倍，写的时候要小心，容易看错。

#include<bits/stdc++.h>
using namespace std;
using ll = long long;
ll get(ll n)
{
    ll res = 0;
    while(n)
    {
        res += n % 10;
        n /= 10;
    }
    return res;
}
int main()
{
    int n;
    cin>>n;
    for(int i = 1;i <= n;i++)
    {
        ll a,b;
        cin>>a>>b;
        ll sa = get(a);
        ll sb = get(b);
        if(!(a % sb) && (b % sa))
            cout<<"A";
        else if(!(b % sa) && (a % sb)) 
            cout<<"B";
        else{
            if(a > b) cout<<"A";
            else cout<<"B";
        }
        if(i != n) cout<<"\n"; 
    }
    return 0;
}

L2

L2-045 堆宝塔

题目怎么说就怎么做，这里用数组模拟栈，用起来更舒服一些，个人觉得比STL好用

#include<bits/stdc++.h>
using namespace std;
const int N = 10100;
int cnt,high;
int va[N],pa;
int vb[N],pb;
int main()
{
    int n;
    cin>>n;
    for(int i = 1;i <= n;i++)
    {
        int x;
        cin>>x;
        if(pa == 0) va[pa++] = x;
        else
        {
            if(va[pa-1] > x) va[pa++] = x;
            else
            {
                if(pb == 0 || x > vb[pb-1]) 
                    vb[pb++] = x;
                else
                {
                    cnt ++;
                    high = max(high,pa);
                    pa = 0;
                    while(pb)
                    {
                        if(vb[pb-1] > x)
                        {
                            va[pa++] = vb[--pb];
                        }
                        else break;
                    }
                    va[pa++] = x;
                }
            }
        }
    }
    if(pa)
    {
        cnt++;
        high = max(high,pa);
    }
    if(pb)
    {
        cnt++;
        high = max(high,pb);
    }
    cout<<cnt<<" "<<high;
    return 0;
}

L2-046 天梯赛的赛场安排

纯暴力写法用结构体排序 ，然后会收获两个TLE，只能得18分
这题要用优先队列去优化这个排序过程，优先队列底层用堆实现的，大根堆就是从大到小排序，小根堆是从小到大排序，默认是大根堆，所有本题直接用默认就好了。
sort排序最快也要O(nlogn)，使用优先队列将一个无序序列调整成有序序列只需要O(n),并且向堆中加入元素，只需要O(logn)，这大大降低这道题的时间复杂度。
其次这题可以直接先将各个大学可以分配的考场先计算出来，如果某个大学参赛人数刚好是c的整数倍，那么他已经分配好了不用加入优先队列中。

#include<bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
const int INF = 0x3f3f3f3f,mod = 1000000007;
using ll = long long;
int T;
const int N = 5010;
struct Node{
    string name;
    int num;//未安排人数
    //运算符重载
    bool operator < (const Node &s) const
    {
        return num < s.num;
    }
}f[N];
int n,c;
int cnt;
map<string,int>mp;
string order[N];
inline void run()
{
    cin>>n>>c;
    priority_queue<Node>q;//默认大根堆
    for(int i = 1;i <= n;i++)
    {
        string name;int num;
        cin>>name>>num;
        order[i] = name;
        int cls = num / c;
        cnt += cls;
        num = num - cls * c;
        if(num != 0)
            q.push({name,num});
        mp[name] = cls;
    }    
    vector<int>cls;
    while (q.size())
    {
        auto t = q.top();
        q.pop();
        string name = t.name;
        int num = t.num;
        bool flag = false;
        for(int j = 0;j < cls.size();j++)
        {
            if((c - cls[j]) >= num)
            {
                cls[j] += num;
                mp[name] += 1;
                flag = true;
                break;
            }
        }
        if(!flag)
        {
            cnt++;
            cls.push_back(num);
            mp[name] += 1;
        }
    }
    
    for(int i = 1;i <= n;i++)
        cout<<order[i]<<" "<<mp[order[i]]<<endl;
    cout<<cnt;
}
int main()
{
    IOS;
    // cin>>T;
    // while (T--)
    //     run();
    run();
    return 0;
}

L2-047 锦标赛

先了解一下败者树，这是一个数据结构中比较冷门的考点，详情可以看王道的讲解

下图是龙珠里武林大赛比武的败者树在这里插入图片描述
败者树—可以视为一棵完全二叉树（多一个头头）。k个叶结点分别是当前参加比较的元素，非叶子结点用来记忆左右子树中的“失败者”，而让胜利者往上继续进行比较，一直到根结点。

这题就是给出败者树，然后需要还原原序列，虽然我知道要这么做，但是还是没写出来/(ㄒoㄒ)/~~，下面的代码是另一位博主的，原代码链接点这。
大体思路如下：
每次我们都可以完善数组的一半，然后剩下一半
完善的过程：
对于第一层，是第一次比赛的结果，相邻两个进行比较的结果，因此，我们可以把第一层第i个数的位置放在原始数组i*2-1中
对于接下来的几层，它能加入原始数组的条件就是 它的数值不小于前一层两个对应位置分别的所组成子树的最大值 否则它将无法加入到原始数组中去
为了实现构造还要建立一个数组，来记录该位置的一下位置在哪里

#include<bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
const int INF = 0x3f3f3f3f,mod = 1000000007;
using ll = long long;
const int N = 20,M = (1 << 19);
int T;
int k;
int ans[M];//结果数组
int a[N][M],id[N][M];//a数组存储输入的数据，id存储还能放数的空余位置
inline void run()
{
    cin>>k;
	int flag = 1,max1;
	for(int i = 1;i <= k;i++){
		for(int j = 1;j <= (1<<(k-i));j++){
			cin>>a[i][j];
			if(i == 1) ans[j*2-1]=a[i][j],id[i][j]=j*2; //loser放在左儿子，winner放在右儿子
			else{
				max1 = max(a[i][j],max(a[i-1][j*2],a[i-1][j*2-1]));//记录所构成子树的最大数值
				if(a[i][j] < a[i-1][j*2] && a[i][j] < a[i-1][j*2-1]){
					flag = 0;
					break;
				}else if(a[i][j] >= a[i-1][j*2]){
					ans[id[i-1][j*2]] = a[i][j];
					id[i][j] = id[i-1][j*2-1];
				}else{
					ans[id[i-1][j*2-1]] = a[i][j];
					id[i][j] = id[i-1][j*2];
				}
				a[i][j] = max1;
			}
		}
	}
	cin >> max1;
	if(a[k][1] <= max1) ans[id[k][1]] = max1;
	else flag = 0;
	if(flag == 0) cout<<"No Solution\n";
	else{
		for(int i = 1;i <= (1<<k);i++) 
            cout<<ans[i]<<" \n"[i==(1<<k)];
	}
}
int main()
{
    IOS;
    // cin>>T;
    // while (T--)
    //     run();
    run();
    return 0;
}

L2-048 寻宝图

这里需要用vector来存，n*m <= 1e5，二维数组只能开到1e4。
本来想着数据可能很弱，打算直接用二维数组卡过去(/≧▽≦)/，结果被卡了一个点（24分）/(ㄒoㄒ)/~~。
回到这道题，就是一个连通块问题，写个dfs或者bfs就行了，所以这题关键是要想到用vector。

#include<bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int>f[N],st[N];
int cnt,sum;
bool flag;
int n,m;
int dx[] = {-1,0,1,0},dy[] = {0,1,0,-1};
void dfs(int x,int y)
{
    st[x][y] = true;
    if(f[x][y] > 1) flag = true;
    for(int i = 0;i < 4;i++)
    {
        int xx = x + dx[i],yy = y + dy[i];
        if(xx >= 1 && xx <= n&&yy >= 1&&yy <= m&&f[xx][yy]&&!st[xx][yy])
        {
            if(f[xx][yy] > 1) flag = true;
            dfs(xx,yy);
        }
    }
}
int main()
{
    cin>>n>>m;
    for(int i = 1;i <= n;i++)
    {
        f[i].push_back(0);
        st[i].push_back(0);
        for(int j = 1;j <= m;j++)
        {
            char c;
            cin>>c;
            f[i].push_back(c-'0');
            st[i].push_back(0);
        }
    }
    for(int i = 1;i <= n;i++)
        for(int j = 1;j <= m;j++)
        {
            if(f[i][j] && !st[i][j])
            {
                flag = false;
                sum++;
                dfs(i,j);
                if(flag) cnt++;
            }
        }
    cout<<sum<<" "<<cnt;
    return 0;
}

END✅

MrNeoJeep
关注
  • 4
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
2023PAT天梯赛
m0_74376876的博客
04-23 1676
天梯赛
PTA 团体设计天梯赛题解L1（水）
01-23
团体设计天梯赛是PTA举办的一种团队竞技活动，旨在通过不同难度级别的题目，帮助参赛者逐步提升编程能力，增强团队合作精神。"L1（水）"通常表示这个阶段的题目相对简单，适合初学者入门。 在这个压缩包文件中，你...
2023天梯赛真题L2-3 锦标赛
m0_63938020的博客
05-08 2841
重点是有两种解的情况，如果有两种解，我们先试用其中一种解，然后递归调用solve函数，若函数返回后发现flag变成false，也就是说下层出现了无解的情况时，我们将子节点的胜者调换位置，将flag设置为true，也就是尝试另一种方案，再递归解决后面的层，如果这一次flag还是变成false了，那就说明确实无解。solve函数中，我们先写递归出口，即当当前要讨论的节点的编号已经大于总节点数，即已经到尽头，或者已经发现之前有无解的情况的出现时，直接返回，否则继续讨论。场比赛)，取它的父节点，也就是第。
PTA L2-047 锦标赛
qq_51007706的博客
04-19 269
把每一场比赛看作满二叉树的一个节点，父节点递归遍历子节点的结果，进行试填。
【2023团体程序设计天梯赛CCCC】GPLT2023，L1~L2部分（PTA，L1-089~L1-096，L2-045~L2-048）题解代码&复盘
小哈里的博客
04-25 3031
【2023团体程序设计天梯赛CCCC】GPLT2023，L1~L2部分（PTA，L1-089~L1-096，L2-045~L2-048）题解代码&复盘概要 L1-089 最好的文档 5 L1-090 什么是机器学习 5 L1-091 程序员买包子 10 L1-092 进化论 10 L1-093 猜帽子游戏 15 L1-094 剪切粘贴 15 L1-095 分寝室 20 L1-096 谁管谁叫爹 20 L2-045 堆宝塔 25 L2-046 天梯赛的赛场安排 L2-047 锦标赛 25 L2-048 寻宝图
PTA拼题A2023跨年挑战赛
A2901377401的博客
01-01 1628
PTA拼题A2023跨年挑战赛
天梯赛选拔赛补题
ntr851217的博客
03-22 140
可以先求1到n中同时满足是2、5、11、13倍数的数，由于2和5当中10被算了两次···可以推出两个数的最小公倍数都多算了一次，所以还需要减去10，22，26，55，65，143的倍数,因为减去的同时会把像2、5、11的倍数减去，所以要加上110、130、286、715的倍数，同理要减去2、5、11、13的倍数。思路：易知可获得的糖果的总数一定不会超过P，可以将两堆糖果的总数进行求模，求模后的结果就是剩下slp可以得到的糖果数量，而我们需要求的是剩下的哪两堆的总和最大并且不超过每包的糖果数量。
PTA 天梯赛习题思路和题解
04-20
PTA（Programming Training Arena）是浙江大学开发的一个在线编程竞赛平台，旨在帮助学生和程序员提升编程技能，通过参加“天梯赛”这样的比赛模式，可以挑战各种难度级别的编程题目，逐步提高自己的编程能力和算法...
PTA 天梯赛习题思路和题解.zip
最新发布
04-21
PTA（Programming Training Arena）天梯赛是一种在线编程竞赛，旨在提升参赛者的编程技能和算法理解能力。在天梯赛中，参赛者需要解决一系列具有挑战性的编程问题，这些问题涵盖了从基础的数据结构到复杂的算法设计...
PTA天梯赛L1部分代码
10-18
"PTA天梯赛L1部分代码"指的是在该平台上，第一级别（Level 1）的一些竞赛题目所使用的代码。这些代码可能包括了参赛者解决这些问题的算法实现、数据结构运用以及编程技巧。 L1级别的题目通常相对简单，适合初学者...
PTA团体天梯赛习题集.zip
04-21
"PTA团体天梯赛习题集.zip"这个压缩包文件显然与编程竞赛相关，特别是“天梯赛”这一主题，暗示了这是一个帮助参赛者提升技能的练习平台。PTA，全称为“Programming Training Arena”，通常指的是一个在线编程训练...
2023天梯赛题解
qq_45803851的博客
04-23 1707
2023程序设计团体天梯赛题解
pta L1-093 猜帽子游戏
2401_82661391的博客
02-10 384
咕嘟咕嘟
L2-046 天梯赛的赛场安排
Mz_yuner的博客
11-15 357
【代码】L2-046 天梯赛的赛场安排。
L2-047 锦标赛-PAT团体程序设计天梯赛GPLT
柳婼 の blog
11-11 1074
第 2 轮共 2 场比赛：第 1 轮第 1 场的胜者 vs 第 1 轮第 2 场的胜者，第 1 轮第 3 场的胜者 vs 第 1 轮第 4 场的胜者。在一场比赛中，若两名选手的能力值不同，则能力值较大的选手一定会打败能力值较小的选手；若两名选手的能力值相同，则两名选手都有可能成为胜者。第 1 轮共 4 场比赛：选手 1 vs 选手 2，选手 3 vs 选手 4，选手 5 vs 选手 6，选手 7 vs 选手 8。第 3 轮共 1 场比赛：第 2 轮第 1 场的胜者 vs 第 2 轮第 2 场的胜者。
C语言 PTA 习题目录
weixin_63484669的博客
03-12 4099
自己方便复习整理的
PTA L1-090 什么是机器学习 (5 分)
00后的博客
04-22 1878
什么是机器学习？上图展示了一段面试官与“机器学习程序”的对话：
2023年天梯赛(l1 - l2全部题解）（第十二届）
热门推荐
qq_60755115的博客
04-23 1万+
【代码】2023年天梯赛(l1 - l2全部题解）
2023pta团队天梯赛题目
04-14
2023 PTA团队天梯赛是一个面向大学生的编程竞赛，由浙江大学计算机科学与技术学院主办。每年都会发布一系列的编程题目供参赛队伍解答。 很抱歉，我无法提供具体的2023 PTA团队天梯赛题目，因为我无法获取实时的比赛信息。但是一般来说，PTA团队天梯赛的题目涵盖了各种算法和数据结构的知识，包括但不限于图论、动态规划、贪心算法、字符串处理等等。题目难度从简单到困难不等，旨在考察参赛选手的编程能力和解决问题的能力。 如果你对具体的题目感兴趣，建议你关注PTA官方网站或者相关的竞赛平台，他们会发布最新的比赛信息和题目。希望这个回答对你有帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值