2022天梯L1-L2题解_7-11 老板的作息表 分数 25 作者 陈越 单位 浙江大学 zcy.png 新浪微博上有人发了

总结

整个天梯赛的赛场体验一般，最开始看的L2-1,也确实因为题目描述过长，失去耐心，立马转至L1开始作答。从第1题到第10题均未卡题，毕竟知识点都差不多门清。但是在第11题，L2-3开始便卡死了，赛场上想了很多，在补题时发现，思路是正确的，但是有些细节也确实没有处理好。同时在WA了三次后，依旧在死磕它，没有去尝试第四题，qwq.主要第四题题目看完也是蒙圈状态，就选择继续做2-3.整体题目不难，就像陈越姥姥在知乎说的，知识没有变，只是出题风格年轻化了。（直接就是阅读理解）。
这里给出L1的思路，L2的AC代码。

L1-1

输出字符串加上2022-04-23即可。

L1-2

总量除以速度得到时间

L1-3

对年龄的分类讨论，最多9种情况，但是有几种可以合并，一点if-else出结果。

L1-4

阶乘的计算，直接一个循环完成。

L1-5

从6开始向下依次取数，如果遇到已出现的数字则多减一。

L1-6

将字符判断奇偶性，然后按照题目给定算法判定即可。char的隐式转化为int不影响两个相邻字符的奇偶性。

L1-7

对所有出现的行列去重，得到技能所占用的行列数，那么用总的行列减去用掉的行列，将剩余的行列相乘得到的积便是安全区域大小。

L1-8

创建一个结构体，里面包含天梯分数，到达企业线的人数，未达企业线的人数三个变量。按照天梯分数排序。第一轮推荐便可以将175以上，到达企业线的人全部推荐，并且在各分数中未达企业线的人中推荐一人。随后的每一轮推荐便只剩下各分数中未达企业线的人，一轮推荐一个。最后得到的便是结果。

---

下边是L2的题目与题解。

L2-1 插松枝

人造松枝加工场的工人需要将各种尺寸的塑料松针插到松枝干上，做成大大小小的松枝。他们的工作流程（并不）是这样的：

每人手边有一只小盒子，初始状态为空。
每人面前有用不完的松枝干和一个推送器，每次推送一片随机型号的松针片。
工人首先捡起一根空的松枝干，从小盒子里摸出最上面的一片松针 —— 如果小盒子是空的，就从推送器上取一片松针。将这片松针插到枝干的最下面。
工人在插后面的松针时，需要保证，每一步插到一根非空松枝干上的松针片，不能比前一步插上的松针片大。如果小盒子中最上面的松针满足要求，就取之插好；否则去推送器上取一片。如果推送器上拿到的仍然不满足要求，就把拿到的这片堆放到小盒子里，继续去推送器上取下一片。注意这里假设小盒子里的松针片是按放入的顺序堆叠起来的，工人每次只能取出最上面（即最后放入）的一片。
当下列三种情况之一发生时，工人会结束手里的松枝制作，开始做下一个：
（1）小盒子已经满了，但推送器上取到的松针仍然不满足要求。此时将手中的松枝放到成品篮里，推送器上取到的松针压回推送器，开始下一根松枝的制作。

（2）小盒子中最上面的松针不满足要求，但推送器上已经没有松针了。此时将手中的松枝放到成品篮里，开始下一根松枝的制作。

（3）手中的松枝干上已经插满了松针，将之放到成品篮里，开始下一根松枝的制作。

现在给定推送器上顺序传过来的 N 片松针的大小，以及小盒子和松枝的容量，请你编写程序自动列出每根成品松枝的信息。

题意

小盒子即栈，初始为空，推送器可以看成一个队列，也可以直接通过循环逐个处理。本处将其视为队列。栈的大小给定，并且优先从栈中获取松针，要求每次的松针小于等于上一次获取的松针，当获取的松针数目达到K时，回归初始状态，向新的空树中插入。

输入

输入在第一行中给出 3 个正整数：$N(\le 10^3)$，为推送器上松针片的数量；M（≤20）为小盒子能存放的松针片的最大数量；K（≤5）为一根松枝干上能插的松针片的最大数量。
随后一行给出 N 个不超过 100 的正整数，为推送器上顺序推出的松针片的大小。

输出

每支松枝成品的信息占一行，顺序给出自底向上每片松针的大小。数字间以 1 个空格分隔，行首尾不得有多余空格。

输入样例

8 3 4
20 25 15 18 20 18 8 5
1
2

输出样例

20 15
20 18 18 8
25 5
1
2
3

题解

由题目可以看出，只有当栈和队列均空的时候结束运行，栈满时，若是队列头不能满足条件，便回到初始状态，栈不满时，可以将队列头放入栈中，进行下一轮判断。优先考虑从栈中获取数值。

代码

#include<bits/stdc++.h>
using namespace std;
stack<int> st;//盒子
queue<int> qu;//推送器
int main(){
    int n,m,k,x;
    cin >> n >>m >> k;
    for(int i = 0;i<n;++i){
        cin >> x;
        qu.push(x);
    }
    int f = -1,c = 0;
    while(!st.empty()||!qu.empty()){
        if(f==-1){//向空树中插入
            if(!st.empty()){
                f = st.top();
                cout << f;
                st.pop();
            }
            else {
                f = qu.front();
                cout << f;
                qu.pop();
            }
            ++c;//已插入数目
        }
        else{
            if(c==k){//树满
                c = 0,f = -1;
                cout <<"\n";
                continue;
            }
            if(!st.empty()&&st.top()<=f){//栈顶符合条件
                f = st.top();
                st.pop();
                cout <<" "<<f;
                ++c;
            }
            else if(!qu.empty()&&qu.front()<=f){//队列头符合条件
                f = qu.front();
                qu.pop();
                cout <<" "<<f;
                ++c;
            }
            else if(st.size()<m&&!qu.empty()){//均不符合条件且栈未满
                st.push(qu.front());
                qu.pop();
            }
            else {//栈满，且均不符合条件
                c = 0,f = -1;
                cout <<"\n";
            }
        }
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

L2-2 老板的作息表

新浪微博上有人发了某老板的作息时间表，表示其每天 4:30 就起床了。但立刻有眼尖的网友问：这时间表不完整啊，早上九点到下午一点干啥了？
本题就请你编写程序，检查任意一张时间表，找出其中没写出来的时间段。

输入

输入第一行给出一个正整数 N，为作息表上列出的时间段的个数。随后 N 行，每行给出一个时间段，格式为：

hh:mm:ss - hh:mm:ss

其中 hh、mm、ss 分别是两位数表示的小时、分钟、秒。第一个时间是开始时间，第二个是结束时间。题目保证所有时间都在一天之内（即从 00:00:00 到 23:59:59）；每个区间间隔至少 1 秒；并且任意两个给出的时间区间最多只在一个端点有重合，没有区间重叠的情况。

输出

按照时间顺序列出时间表中没有出现的区间，每个区间占一行，格式与输入相同。题目保证至少存在一个区间需要输出。

输入样例

8
13:00:00 - 18:00:00
00:00:00 - 01:00:05
08:00:00 - 09:00:00
07:10:59 - 08:00:00
01:00:05 - 04:30:00
06:30:00 - 07:10:58
05:30:00 - 06:30:00
18:00:00 - 19:00:00
1
2
3
4
5
6
7
8
9

输出样例

04:30:00 - 05:30:00
07:10:58 - 07:10:59
09:00:00 - 13:00:00
19:00:00 - 23:59:59
1
2
3
4

题解

可以将一个时间段视为一个结构体，对开始时间排序，然后通过前一个的结束时间与当前的开始时间比较，查看是否存在时间差，有则输出。

代码

#include<bits/stdc++.h>
using namespace std;
struct P{
    int h1,m1,s1,h2,m2,s2;
}node[100010];
bool cmp(P a,P b){
    if(a.h1==b.h1){
        if(a.m1==b.m1){
            return a.s1<b.s1;
        }
        return a.m1<b.m1;
    }
    return a.h1<b.h1;
}
int main(){
    int n;
    cin >> n;
    for(int i = 0;i<n;++i){
        scanf("%d:%d:%d - %d:%d:%d",&node[i].h1,&node[i].m1,&node[i].s1,&node[i].h2,&node[i].m2,&node[i].s2);
    }
    sort(node,node+n,cmp);
    if(node[0].h1!=0||node[0].m1!=0||node[0].s1!=0)//初始时间和00:00:00比较
        printf("00:00:00 - %02d:%02d:%02d\n",node[0].h1,node[0].m1,node[0].s1);
    for(int i = 1;i<n;++i){
        if(node[i-1].h2!=node[i].h1||node[i-1].m2!=node[i].m1||node[i-1].s2!=node[i].s1){
            printf("%02d:%02d:%02d - %02d:%02d:%02d\n",node[i-1].h2,node[i-1].m2,node[i-1].s2,node[i].h1,node[i].m1,node[i].s1);
        }
    }
    if(node[n-1].h2!=23||node[n-1].m2!=59||node[n-1].s2!=59)//末尾结束时间与23:59:59比较
        printf("%02d:%02d:%02d - 23:59:59\n",node[n-1].h2,node[n-1].m2,node[n-1].s2);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

L2-3 龙龙送外卖

龙龙是“饱了呀”外卖软件的注册骑手，负责送帕特小区的外卖。帕特小区的构造非常特别，都是双向道路且没有构成环 —— 你可以简单地认为小区的路构成了一棵树，根结点是外卖站，树上的结点就是要送餐的地址。

每到中午 12 点，帕特小区就进入了点餐高峰。一开始，只有一两个地方点外卖，龙龙简单就送好了；但随着大数据的分析，龙龙被派了更多的单子，也就送得越来越累……

看着一大堆订单，龙龙想知道，从外卖站出发，访问所有点了外卖的地方至少一次（这样才能把外卖送到）所需的最短路程的距离到底是多少？每次新增一个点外卖的地址，他就想估算一遍整体工作量，这样他就可以搞明白新增一个地址给他带来了多少负担。

输入格式:

输入第一行是两个数 N 和 M $(2\le N\le 10^5,1\le M\le 10^5)$，分别对应树上节点的个数（包括外卖站），以及新增的送餐地址的个数。
接下来首先是一行 N 个数，第 i 个数表示第 i 个点的双亲节点的编号。节点编号从 1 到 N，外卖站的双亲编号定义为 −1。
接下来有 M 行，每行给出一个新增的送餐地点的编号 $X_i$ 。保证送餐地点中不会有外卖站，但地点有可能会重复。
为了方便计算，我们可以假设龙龙一开始一个地址的外卖都不用送，两个相邻的地点之间的路径长度统一设为 1，且从外卖站出发可以访问到所有地点。
注意：所有送餐地址可以按任意顺序访问，且完成送餐后无需返回外卖站。

输出格式:

对于每个新增的地点，在一行内输出题目需要求的最短路程的距离。

输入样例:

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

输出样例:

2
4
4
6
1
2
3
4

题解

首先需要对每一个节点的深度进行计算，随后在送餐过程中，得到送餐点到已经走过路径的最小距离的两倍，因为是往返，并且对送餐过程中最深的点进行更新，因为不用回到起点，因此最后停留的位置必然是送餐点中距离最深的。当前面计算的所有距离之和即是在返回原点情况下的最短距离，减去最大深度，便是不返回的最小距离。

代码

#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
int n,m,mx,r;
int fa[100010],deep[100010];
bool vis[100010];
vector<int> vt[100010];
void dep(int x){//计算深度
    for(int i = 0;i<vt[x].size();++i){
        deep[vt[x][i]] = deep[x]+1;
        dep(vt[x][i]);
    }
}
int dfs(int x,int d){//计算当前送餐点到已经走过的路中的最小距离，以及更新最大深度
    if(vis[x]||x==r){
        mx = max(deep[x]+d,mx);
        return d*2;
    }
    vis[x] = true;
    return dfs(fa[x],d+1);
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    cin >> n >>m;
    int k;
    for(int i = 1;i<=n;++i){
        cin >> fa[i];
        if(fa[i]==-1) r = i;
        else vt[fa[i]].push_back(i);
    }
    dep(r);
    int ans = 0;
    for(int i = 1;i<=m;++i){
        cin >> k;
        ans+=dfs(k,0);//往返的总最小路程
        cout << ans-mx<<"\n";
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

L2-4 大众情人

一个人的异性缘不是由最喜欢他/她的那个异性决定的，而是由对他/她最无感的那个异性决定的。我们记一个人 i 在一个异性 j 眼中的距离感为$D_{ij}$;将 i 的“异性缘”定义为$1/ma{x}_{j\in S(i)}{D}_{ij}$，其中 S(i) 是相对于 i 的所有异性的集合。那么“大众情人”就是异性缘最好（值最大）的那个人。
本题就请你从给定的一批人与人之间的距离感中分别找出两个性别中的“大众情人”。

题意：给出的两点间单向的距离，获得所有异性单向距离最短的点序号。

输入格式：

输入在第一行中给出一个正整数 N（≤500），为总人数。于是我们默认所有人从 1 到 N 编号。随后 N 行，第 i 行描述了编号为 i 的人与其他人的关系，格式为：

性别 K 朋友1:距离1 朋友2:距离2 …… 朋友K:距离K

其中 性别 是这个人的性别，F 表示女性，M 表示男性；K（<N 的非负整数）为这个人直接认识的朋友数；随后给出的是这 K 个朋友的编号、以及这个人对该朋友的距离感。距离感是不超过$10^6$的正整数。
题目保证给出的关系中一定两种性别的人都有，不会出现重复给出的关系，并且每个人的朋友中都不包含自己。

输出格式：

第一行给出自身为女性的“大众情人”的编号，第二行给出自身为男性的“大众情人”的编号。如果存在并列，则按编号递增的顺序输出所有。数字间以一个空格分隔，行首尾不得有多余空格。

输入样例：

6
F 1 4:1
F 2 1:3 4:10
F 2 4:2 2:2
M 2 5:1 3:2
M 2 2:2 6:2
M 2 3:1 2:5
1
2
3
4
5
6
7

输出样例：

2 3
4
1
2

题解

因为只需要得到单向的最短距离，同时要求任意两人间的最短距离，这里采用Folyd算法，时间复杂度为$O(n^3)$，最后比较即可得到结果。

代码

#include<bits/stdc++.h>
using namespace std;
bool s[510];//性别
int dist[510][510];//任意两人间的单向最短距离
int ans[510];//最远的异性所在距离
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n,k,x,y;
    char sex,ch;
    cin >> n;
    memset(dist,0x3f,sizeof dist);
    for(int i = 1;i<=n;++i){
        cin >> sex >> k;
        if(sex=='M') s[i] = true;
        for(int j = 0;j<k;++j){
            cin >> x >> ch >> y;
            dist[i][x] = y;
        }
    }
    for(int k = 1;k<=n;++k){//Folyd
        for(int i = 1;i<=n;++i){
            for(int j = 1;j<=n;++j){
                dist[i][j] = min(dist[i][j],dist[i][k]+dist[k][j]);//推理，更新
            }
        }
    }
    for(int i = 1;i<=n;++i){//对任意两点比较
        for(int j = 1;j<=n;++j){
            if(i!=j&&s[i]^s[j]){//异性间最大的最短距离
                ans[i] = max(ans[i],dist[j][i]);
            }
        }
    }
    int t = 0;
    int a[510],mx = 0x3f3f3f3f;
    for(int i = 1;i<=n;++i){//女性大众情人比较
        if(!s[i]&&mx>ans[i]){
            t = 1;
            a[0] = i;
            mx = ans[i];
        }
        else if(!s[i]&&mx==ans[i]){
            a[t++] = i;
        }
    }
    cout << a[0];
    for(int i = 1;i<t;++i) cout <<" "<<a[i];
    cout <<"\n";
    mx = 0x3f3f3f3f,t = 0;//同上
    for(int i = 1;i<=n;++i){
        if(s[i]&&mx>ans[i]){
            t = 1;
            a[0] = i;
            mx = ans[i];
        }
        else if(s[i]&&mx==ans[i]){
            a[t++] = i;
        }
    }
    cout << a[0];
    for(int i = 1;i<t;++i) cout <<" "<<a[i];
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65