2023 - 04 - 03 2016天梯赛初赛(L2)练习

已于 2023-05-09 20:38:43 修改
阅读量480 收藏
点赞数
分类专栏： PAT天梯赛 文章标签： 算法 数据结构 图论
于 2023-04-05 16:55:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuyuan12346/article/details/129972224
版权

7-12 关于堆的判断

分数 25

全屏浏览题目

切换布局

作者 陈越

单位 浙江大学

将一系列给定数字顺序插入一个初始为空的小顶堆H[]。随后判断一系列相关命题是否为真。命题分下列几种：

  • x is the root：x是根结点；
  • x and y are siblings：x和y是兄弟结点；
  • x is the parent of y：x是y的父结点；
  • x is a child of y：x是y的一个子结点。

输入格式：

每组测试第1行包含2个正整数N（≤ 1000）和M（≤ 20），分别是插入元素的个数、以及需要判断的命题数。下一行给出区间[−10000,10000]内的N个要被插入一个初始为空的小顶堆的整数。之后M行，每行给出一个命题。题目保证命题中的结点键值都是存在的。

输出格式：

对输入的每个命题，如果其为真，则在一行中输出T，否则输出F。

输入样例：

5 4
46 23 26 24 10
24 is the root
26 and 23 are siblings
46 is the parent of 23
23 is a child of 10

输出样例：

F
T
F
T
#include<bits/stdc++.h>

using namespace std;
const int MAX = 10001;
int N, M, num;
string str;
int Heapmin[MAX];

int find(int x)
{
    for (int i = 1; i <= N; i++)
        if (Heapmin[i] == x)return i;
    return 0;
}

int nums(string s)
{
    bool fs = 0;//区间[−10000,10000]
    int sum = 0;
    for (int i = 0; i < s.size(); i++)
    {
        if(s[i] == '-')fs = 1;
        if (isdigit(s[i]))
        {
            if (!sum)sum = s[i] - '0';
            else
            {
                if (s[i] - '0' == 0)
                    sum *= 10;
                else
                {
                    sum *= 10;
                    sum += s[i] - '0';
                }
            }
        }
    }
    if(fs)return -sum;
    return sum;
}

int main()
{
    //建堆
    cin >> N >> M;
    for (int i = 1; i <= N; i++)
    {
        cin >> Heapmin[i];
        int k = i;
        while (k > 1 && Heapmin[k] < Heapmin[k / 2])
        {
            swap(Heapmin[k], Heapmin[k / 2]);
            k /= 2;
        }
    }
    while (M--)
    {
        cin >> num;
        getline(cin, str);
        if (str.find("root") != str.npos)
        {
            if (Heapmin[1] == num)cout << "T" << endl;
            else cout << "F" << endl;
        }
        else if (str.find("and") != str.npos)
        {
            int T = nums(str);
            if (find(num) / 2 == find(T) / 2)cout << "T" << endl;
            else cout << "F" << endl;
        }
        else if (str.find("parent") != str.npos)
        {
            int T = nums(str);
            if (find(num) == find(T) / 2)cout << "T" << endl;
            else cout << "F" << endl;
        }
        else if (str.find("child") != str.npos)
        {
            int T = nums(str);
            if (find(num) / 2  == find(T))cout << "T" << endl;
            else cout << "F" << endl;
        }
        str.clear();
    }
    return 0;
}

 优化

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

//优化 使用map容器进行查找操作
const int MAX = 10001;
int N, M, num;
string str;
int Heapmin[MAX];
map<int, int>root;
int nums(string s)
{
    bool fs = 0;//区间[−10000,10000]
    int sum = 0;
    for (int i = 0; i < s.size(); i++)
    {
        if (s[i] == '-')fs = 1;
        if (isdigit(s[i]))
        {
            if (!sum)sum = s[i] - '0';
            else
            {
                if (s[i] - '0' == 0)
                    sum *= 10;
                else
                {
                    sum *= 10;
                    sum += s[i] - '0';
                }
            }
        }
    }
    if (fs)return -sum;
    return sum;
}

int main()
{
    //建堆
    cin >> N >> M;
    for (int i = 1; i <= N; i++)
    {
        cin >> Heapmin[i];
        int k = i;
        while (k > 1 && Heapmin[k] < Heapmin[k / 2])
        {
            swap(Heapmin[k], Heapmin[k / 2]);
            k /= 2;
        }
    }
    for (int i = 1; i <= N; i++)root[Heapmin[i]] = i;
    while (M--)
    {
        cin >> num;
        getline(cin, str);
        if (str.find("root") != str.npos)
        {
            if (Heapmin[1] == num)cout << "T" << endl;
            else cout << "F" << endl;
        }
        else if (str.find("and") != str.npos)
        {
            int T = nums(str);
            if (root[num] / 2 == root[T] / 2)cout << "T" << endl;
            else cout << "F" << endl;
        }
        else if (str.find("parent") != str.npos)
        {
            int T = nums(str);
            if (root[num] == root[T] / 2)cout << "T" << endl;
            else cout << "F" << endl;
        }
        else if (str.find("child") != str.npos)
        {
            int T = nums(str);
            if (root[num] / 2 == root[T])cout << "T" << endl;
            else cout << "F" << endl;
        }
        str.clear();
    }
    return 0;
}

7-10 排座位(并查集操作)

布置宴席最微妙的事情，就是给前来参宴的各位宾客安排座位。无论如何，总不能把两个死对头排到同一张宴会桌旁！这个艰巨任务现在就交给你，对任何一对客人，请编写程序告诉主人他们是否能被安排同席。

输入格式：

输入第一行给出3个正整数：N（≤100），即前来参宴的宾客总人数，则这些人从1到N编号；M为已知两两宾客之间的关系数；K为查询的条数。随后M行，每行给出一对宾客之间的关系，格式为：宾客1 宾客2 关系，其中关系为1表示是朋友，-1表示是死对头。注意两个人不可能既是朋友又是敌人。最后K行，每行给出一对需要查询的宾客编号。

这里假设朋友的朋友也是朋友。但敌人的敌人并不一定就是朋友，朋友的敌人也不一定是敌人。只有单纯直接的敌对关系才是绝对不能同席的。

输出格式：

对每个查询输出一行结果：如果两位宾客之间是朋友，且没有敌对关系，则输出No problem；如果他们之间并不是朋友，但也不敌对，则输出OK；如果他们之间有敌对，然而也有共同的朋友，则输出OK but...；如果他们之间只有敌对关系，则输出No way。

输入样例：

7 8 4
5 6 1
2 7 -1
1 3 1
3 4 1
6 7 -1
1 2 1
1 4 1
2 3 -1
3 4
5 7
2 3
7 2

输出样例：

No problem
OK
OK but...
No way

#include<bits/stdc++.h>
using namespace std;
const int MAX = 110;
//首先对于关系分为朋友 敌对 无交集
//其中 敌对只有一对一的情况 但是朋友关系存在相交集 即有共同朋友的情况 但不用考虑共同敌对关系
bool enemy[MAX][MAX];
int frend[MAX];
int N,M,K;
//对于朋友网,可以通过查集合的根,若存在公共根说明在一个朋友圈中间
int find_frend(int x)
{
    if(frend[x] == x)
    {//如果自己就是根
        return x;
    }
    return frend[x] = find_frend(frend[x]);
}
void Union(int A,int B)
{
    int x = find_frend(frend[A]);//将A的朋友圈进行压缩
    int y = find_frend(frend[B]);//将B的朋友圈进行压缩
    if(x != y)//俩人不在一个朋友圈中间
        frend[x] = y;//将A拉入B的朋友圈里
}
int main()
{
    cin>>N>>M>>K;
    //初始关系网
    for(int i = 1; i<=N;i++)frend[i] = i;
    int A,B,C;
    while(M--)
    {
        cin>>A>>B>>C;
        if(C == 1)
        {
            Union(A,B);
        }
        else
        {
            enemy[A][B] = enemy[B][A] = 1;
        }
    }
    while(K--)
    {
        cin>>A>>B;
        if(find_frend(A) == find_frend(B) && !enemy[A][B])
            cout<<"No problem"<<endl;
        else if(find_frend(A) == find_frend(B) && enemy[A][B])
            cout<<"OK but..."<<endl;
        else if(enemy[A][B])
             cout<<"No way"<<endl;
        else 
            cout<<"OK"<<endl;
    }
    return 0;
}

7-9 抢红包

没有人没抢过红包吧…… 这里给出N个人之间互相发红包、抢红包的记录，请你统计一下他们抢红包的收获。

输入格式：

输入第一行给出一个正整数N（≤104），即参与发红包和抢红包的总人数，则这些人从1到N编号。随后N行，第i行给出编号为i的人发红包的记录，格式如下：

KN1​P1​⋯NK​PK​

其中K（0≤K≤20）是发出去的红包个数，Ni​是抢到红包的人的编号，Pi​（>0）是其抢到的红包金额（以分为单位）。注意：对于同一个人发出的红包，每人最多只能抢1次，不能重复抢。

输出格式：

按照收入金额从高到低的递减顺序输出每个人的编号和收入金额（以元为单位，输出小数点后2位）。每个人的信息占一行，两数字间有1个空格。如果收入金额有并列，则按抢到红包的个数递减输出；如果还有并列，则按个人编号递增输出。

输入样例：

10
3 2 22 10 58 8 125
5 1 345 3 211 5 233 7 13 8 101
1 7 8800
2 1 1000 2 1000
2 4 250 10 320
6 5 11 9 22 8 33 7 44 10 55 4 2
1 3 8800
2 1 23 2 123
1 8 250
4 2 121 4 516 7 112 9 10

输出样例：

1 11.63
2 3.63
8 3.63
3 2.11
7 1.69
6 -1.67
9 -2.18
10 -3.26
5 -3.26
4 -12.32
#include<bits/stdc++.h>
using namespace std;
const int MAX = 10001;
int N, K;
//结构体(类)写法
class people
{
public:
    int name;
    int num = 0;//抢到红包个数
    double Money = 0;//
}p[MAX];

bool mysort(people A, people B)
{
    if (A.Money != B.Money)return A.Money > B.Money;
    else
    {
        if (A.num != B.num)return A.num > B.num;
        else return A.name < B.name;
    }
}

int main()
{
    cin >> N;
    for (int i = 1; i <= N; i++)
    {
        p[i].name = i;
        double sum = 0;
        cin >> K;
        int n;
        double m;
        while (K--)
        {
            cin >> n >> m;
            p[n].Money += m;
            p[n].num++;
            sum += m;
        }
        p[i].Money -= sum;
    }
    sort(p + 1, p + N + 1, mysort);
    for (int i = 1; i <= N; i++)
    {
        cout << p[i].name << " ";
                p[i].Money /= 100;
        printf("%.2lf\n", p[i].Money);
    }
    return 0;
}

 7-11 玩转二叉树

#include<bits/stdc++.h>
using namespace std;
int N;
vector<int> in;
vector<int> pre;
class Tree
{
public:
    int val;
    Tree* L;
    Tree* R;
    vector<int> ans;
    Tree(int N)
    {
        val = N;
        L = R = NULL;
    }
    void CX(Tree* root)
    {
        queue<Tree*> Q;
        Q.push(root);
        while (!Q.empty())
        {
            ans.emplace_back(Q.front()->val);
            if (Q.front()->L)Q.push(Q.front()->L);
            if (Q.front()->R)Q.push(Q.front()->R);
            Q.pop();
        }
        for (int i = 0; i < ans.size(); i++)
        {
            cout << ans[i];
            if (i != ans.size() - 1)cout << " ";
        }
    }
};

Tree* Re(Tree* root)
{
    if (!root) return NULL;
    Tree* LL = Re(root->L);
    Tree* RR = Re(root->R);
    root->L = RR;
    root->R = LL;
    return root;
}

Tree* Built(int prel, int prer, int inl, int inr)
{
    if (prel > prer)return NULL;
    Tree* root = new Tree(pre[prel]);
    int i;
    for (i = inl; i < inr; i++)
        if (pre[prel] == in[i])break;
    int j = i - inl;
    root -> L= Built(prel + 1, prel + j, inl, i - 1);
    root -> R= Built(prel + j + 1, prer, i + 1, inr);
    return root;
}


int main()
{
    cin >> N;
    int num;
    for (int i = 0; i < N; i++)
    {
        cin >> num;
        in.emplace_back(num);
    }
    for (int i = 0; i < N; i++)
    {
        cin >> num;
        pre.emplace_back(num);
    }
    Tree* root;
    root = Built(0, N - 1, 0, N - 1);
    root = Re(root);
    root->CX(root);
    return 0;
}

书鸢1236
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2016年 团体程序设计天梯赛 - 初赛
idealism_xxm的专栏
06-04 1万+
L1-1 到底有多二 模拟 L1-2 大笨钟 模拟 L1-3 谁先倒 L1-4 帅到没朋友 标记 L1-5 重要的话说三遍 模拟 L1-6 奇偶分家 模拟 L1-7 输出GPLT 标记 L1-8 后天 模拟 L2-1 抢红包 模拟 L2-2 排座位 并查集 L2-3 玩转二叉树 分治 L2-4 关于堆的判断 小根堆 L3-1 天梯地图 最短路 Dijkstra L3-2 喊山 BFS
【信息奥赛真题】2016年CSP-J初赛答案及解析
08-06 2352
【信息奥赛真题】2016年CSP-J初赛真题
华为软挑赛2023-初赛笔记
weixin_43439761的博客
05-18 2810
2023华为软件精英挑战赛 决赛入围队伍代码分享
团队天梯赛(GLPT) 2016年天梯赛初赛题集
m0_49337600的博客
11-12 352
2016年天梯赛初赛题集 L1： 到底有多二 #include<iostream> using namespace std; string s; int cnt,flag=0; int main() { getline(cin,s); if(s[0]=='-') { for(int i=1;i<s.size();i++) { if(s[i]=='2') cnt++; } i
2023csp-j&s初赛普及组
青少年趣味编程
06-17 780
2023csp-j&s初赛普及组
2023CSP-J初赛所有！知识点合集……
EN-
08-16 1178
2023CSP-J/S
洛谷2020、2021、2022、2023 CSP-J1 CSP-S1 第1轮 初赛模拟
青少年趣味编程
08-23 7033
洛谷2020、2021、2022、2023 CSP-J1 CSP-S1 第1轮 初赛模拟
2023-09-16 CSP-J 第一轮初赛真题解析
艾科叮
09-16 1944
(1)(寻找被移除的元素)问题:原有长度为 n+1公差为1等升数列，将数列输到程序的数组时移除了一个元素，导致长度为 n 的开序数组可能不再连续，除非被移除的是第一个或最后之个元素。12.考虑一个有向无环图，该图包含4条有向边：（1, 2）,（1, 3）,（2, 4）和（3, 4）以下哪个选项是这个有向无环图的一个有效的拓扑排序？除特殊说明外，判断题1.5分，选择题3分，共计40分）17. 将第7行中的"（s-b）*（s-c）"改为"（s-c）*（s-b）"不会影响程序运行的结果（ 对）（2分）
2023-2024华为ICT大赛-计算赛道-广东省省赛初赛-高职组-部分赛题分析【2023.11.18】
ZXW_NUDT的博客
11-18 3927
2023-2024华为ICT大赛-计算赛道-广东省省赛初赛-高职组-部分赛题分析【2023.11.18】
# CSP-J 2023 第一轮试题（初赛）
君义NOIP的博客
09-23 1424
答：选B。声明常量的格式是 const 数据类型 常量名 = 常量值;123456708​076543218​222222218​211111118​221111118​222222118​答：选D列竖式，两数相加，逢8进1。123456700765432122222211答：选A。考察联合体union。
2016-2020年 CSP-J1 CSP-S1 NOIP 初赛真题 答案及解析.rar
09-12
2016-2020年 CSP-J1 CSP-S1 NOIP 初赛真题 答案及解析.rar
2023 CSP-J1 CSP-S1 初赛 第1轮 各种排序算法的比较.pdf
09-13
2023 CSP-J1 CSP-S1 初赛 第1轮 各种排序算法的比较.pdf
2023年CSP-J1 CSP-S1 第1轮初赛 报名指南（B).pdf
07-12
2023年CSP-J1 CSP-S1 第1轮初赛 报名指南（B)
CSP-J1 CSP-S1 第1轮 初赛（2023.09.03）.rar
09-04
CSP-J1 CSP-S1 第1轮 初赛（2023.09.03）
NOIP CSP-J CSP-S 初赛 第1轮 学习资料集（S）-2023.09.21-1000页.pdf
09-21
NOIP CSP-J CSP-S 初赛 第1轮 学习资料集（S）--2023.09.21--1000页
回溯之分割回文串
JINbigXIA的博客
06-04 219
思路：直接看回溯函数的内容，首先我们是取段的，如果这一段不行那就往后面加1，直到加道循环结束。如果可以取端，并且取到了最后一段，也就是开始的startIndex大于等于size那么就代表这一条都是回文字符串。然后需要一个判断函数，判断字符串是否为回文字符串，如果是往path里面加。学到的新函数：array.substr( a ,b) a表示字符串的开始，b表示数量 含义：选取字符串array从a开始往后的b个数。难点：这里用到一个很取段的思路，其实和取点的内容差不多，但是取端更难理解。
TypeScript算法每日一题：一维数组的动态和（1480）
海风依旧
06-04 158
TypeScript算法每日一题：一维数组的动态和（1480）
算法-找出N个数组的共同元素
Python领域优质萌新创作者
06-02 553
3.1、使用集合的intersection_update方法，将当前编辑的新闻编号集合与common_news_set取交集，并更新common_news_set。1.1、使用集合的交集操作找出被所有编辑共同编辑过的新闻：遍历每个新闻集合进行交集操作，时间复杂度为O(K)，其中K为所有编辑操作的总数。3.2、这样，common_news_set中将保留与当前编辑共同编辑过的新闻编号，即找到所有编辑共同编辑过的新闻编号的交集。news_ids: 一个包含N个列表的列表，每个列表包含一个编辑编辑过的新闻编号。
二叉树的统一迭代法-前序中序后序-力扣
最新发布
why_12134的博客
06-05 155
通过对入栈的节点进行标记，只有当标记出现时，才将该元素添加到输出数组中，否则就继续遍历下去。通过更改标记节点 和左右节点的入栈顺序，从而达到只需修改代码顺序，就能切换功能，实现代码统一的目的。之前写的二叉树的前中后序遍历的迭代方法，中序遍历与前序后序遍历的代码并不统一，无法像递归那样只是修改顺序，就可以完成，在看完代码随想录二叉树的统一迭代法的章节后，记录一下。，可以发现，使用NULL来标记需要处理的节点，在遍历时，只需更改左右节点和中间节点的入栈顺序，就能实现不同的遍历顺序。
csp-j初赛的模拟练习
08-10
CSP-J初赛的模拟练习是为了帮助学生更好地准备和了解CSP-J初赛的考试内容和类型而设立的。这些模拟练习通常由教育机构、竞赛培训机构或线上平台提供。考试内容涵盖了计算机科学的各个方面，如编程语言、数据结构、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值