北京师范大学第十六届程序设计竞赛决赛-重现赛 ACFGI

Posted 2020-11-01 starry

A 塞特斯玛斯塔

题目描述

 

quailty是一名狂热的ACM音游选手，沉迷各种音乐游戏，比如Lunatic Rave 2，osu!之类的。

今天，quailty玩的是国内游戏厂商雷亚（并不是赞助商）出品的一款音乐游戏Cytus。

游戏中，玩家需要随着游戏界面中上下移动的扫描线来适时演奏对应音符。

当上下移动的黑色线（扫描线）与圆形的物体（音符）的圆心重合时点击音符。

普通音符（图中第一种）只需点击即可。

锁链音符（图中第二种）将带箭头的音符（滑块）按下后不要松开，并将滑块沿着斜线和圆点组成的路径拖动，直至拖动到最后一个圆点处方可松开。注意拖动过程中应保持滑块圆心始终与扫描线重合。

长按音符（图中第三种）按下后不要松开，原地不动，等扫描线到达其末端并显示判定结果后方可松开。

Cytus共有五种判定，从好到坏依次为：彩PERFECT、黑PERFECT、GOOD、BAD、MISS。

得分中包括了90%的“判定分”和10%的“连击分”，而连击分是累进计算的，断COMBO对其影响很大，往往只要有1个MISS就会损失几万的连击分。

彩PERFECT和黑PERFECT在计算得分时一视同仁，只要全部PERFECT即可获得满分，满分为1000000，被称为MILLION Master。

quailty真的很严格，如果打完一把没有拿到MILLION Master，他就认为自己是NAIVE Noob。

现在给你quailty打出的判定序列，请你输出这次游戏的评价是MILLION Master还是NAIVE Noob。

输入描述:

第一行是一个正整数T ( 1 ≤ T ≤ 5 )，表示测试数据的组数，
每组测试数据，第一行是一个正整数n ( 1 ≤ n ≤ 100000 )，表示该组测试数据包含的判定数。接下来的n行，每行包含"PERFECT"、"GOOD"、"BAD"、"MISS"之中的一个字符串，表示quailty打出的一个判定。

输出描述:

对于每组数据，输出一行，包含一个字符串，表示这次游戏的评价。

示例1

输入

2
5
PERFECT
PERFECT
PERFECT
PERFECT
PERFECT
10
PERFECT
MISS
PERFECT
BAD
BAD
GOOD
BAD
GOOD
GOOD
MISS

输出

MILLION Master
NAIVE Noob

签到题

 

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 
 4 int main() {
 5     int n, t;
 6     cin >> t;
 7     while(t--) {
 8         cin >> n;
 9         string s;
10         bool flag = true;
11         while(n--) {
12             cin >> s;
13             if(s != "PERFECT") flag = false;
14         }
15         if(flag) printf("MILLION Master\n");
16         else printf("NAIVE Noob\n");
17     }
18     return 0;
19 }

 

C 萌萌哒身高差

题目描述

 

“清明时节雨纷纷，路上行人欲断魂。”

然而wfy同学的心情是愉快的，因为BNU ACM队出去春游啦！并且，嗯。。。

以下是wfy同学的日记：

昨天，何老师告诉我们：明天我们去春游，大家准备好喝的和吃的哦！
大家听了都兴奋起来，有的欢呼，有的鼓掌，开心得不得了。第二天，我们早早地来到学校，迫不及待地上了车，来到了公园。一进门，啊，太美了！公园中有那么多树，有高有矮，有粗有瘦，密密的，在春风吹拂下轻轻摇摆着，像是欢迎我们的到来。公园中有那么多的鲜花，有红有黄，有紫有白，散发着淡淡的清香，闻得我们都醉了。公园的边角上有一条清澈的小河，河水缓缓地流淌着，可以看到水里的鱼儿在快活地游来游去，多自在啊！水草碧绿碧绿的，多新鲜啊！小河的旁边是一片小树林，远远望去一片鲜绿。我们在里面吃东西、做游戏、捉迷藏，玩得疯极了。树林的后面是连绵起伏的小山坡，蜿蜿的真像一条游动的蛇。当然，我觉得公园的天空也很美。它万里无云，一碧如洗，很清澈。小鸟在展翅飞翔，它们形态各异，一会儿上升，一会儿下滑，一会儿吃虫，一会儿在小树林里休息，非常悠闲。快乐时光总是那么短暂，很快，天色就昏暗了。我们依依不舍地上了车，回到了学校，我真希望明年的春天还能再来看看这美丽的公园。
回到学校后，何老师说：请大家排成一排，我们来拍照片啦！
何老师特别喜欢萌的东西，比如**，比如****，等等。
何老师认为，同学们站成一排时，相邻两个同学身高相差越多，这两个同学站在一起越萌。
那么所有相邻两个同学的身高差加起来越大，拍出来的照片就越萌，也就是这张照片的萌力指数。
何老师希望拍出来的照片的萌力指数尽可能大。
然而何老师并不是数学老师，而是语文老师。何老师觉得很GG。
何老师只想知道，如果让同学们随便站成一排(站成所有排列的可能性都相等)，萌力指数的数学期望是多少。
聪明的我一下子就算出了答案，然后何老师就奖励了我一个很萌的礼物。
今天真的好开心。

BNU ACM队共有n名同学，身高分别是，聪明的你能计算出何老师想要的数学期望吗？

输入描述:

第一个是一个正整数T(T ≤ 20)，表示测试数据的组数，
每组测试数据只有一行，包含一个整数n(2 ≤ n ≤ 100)。

输出描述:

对于每组测试数据，输出一行，包含一个实数，表示萌力指数的数学期望值，要求相对误差不超过，

也就是说，令输出结果为a，标准答案为b，若满足，则输出结果会被认为是正确答案。

示例1

输入

2
2
3

输出

1.000000000000
2.666666666667

说明

对于第二组样例，所有可能的排列是[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]，所以答案是

 

找规律

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 int a[110];
 4 int main() {
 5     int t, n;
 6     cin >> t;
 7     while(t--) {
 8         cin >> n;
 9         printf("%.12f\n",1.0*(n*n-1)/3.0);
10     }
11     return 0;
12 }

 

 F 汤圆防漏理论

题目描述

ghc很喜欢吃汤圆，但是汤圆很容易被粘(zhān)漏。

根据多年吃汤圆经验，ghc总结出了一套汤圆防漏理论：

互相接触的汤圆容易粘(zhān)在一起，并且接触面积不同，粘(zhān)在一起的粘(nián)度也不同。

当ghc要夹起一个汤圆时，这个汤圆和现在碗里与这个汤圆接触的所有汤圆之间的粘(nián)度的和，如果大于汤圆的硬度，这个汤圆就会被粘(zhān)漏。

今天ghc又要煮汤圆啦，今天要煮n个汤圆，并且摆盘的方法已经设计好：

汤圆按照编号，有m对汤圆互相接触，用x_i, y_i, z_i表示编号为x_i和y_i的两个汤圆互相接触，粘(nián)度为z_i。

汤圆当然是越软越好吃，但是ghc的厨艺只允许把所有汤圆煮成同样的硬度。那么，汤圆的硬度最小可以是多少，可以满足吃的过程中，存在一种夹汤圆的顺序，使得没有汤圆会被粘(zhān)漏呢？

注意：

不考虑汤圆的重力作用；

不能同时夹多个汤圆；

吃完汤圆一定要喝点汤。

输入描述:

第一行是一个正整数T(≤ 5)，表示测试数据的组数，

对于每组测试数据，

第一行是两个整数n,m(1≤ n,m≤ 100000)，

接下来m行，每行包含三个整数x_i, y_i, z_i(1≤ x_i, y_i ≤ n, x_i ≠ y_i, 1 ≤ z_i ≤ 1000000)，

同一对汤圆不会出现两次。

输出描述:

对于每组测试数据，输出一行，包含一个整数，表示汤圆硬度的最小值。

示例1

输入

1
4 6
1 2 2
1 3 2
1 4 2
2 3 3
2 4 3
3 4 5

输出

6

每次把权值和最小的吃掉。然后没吃掉的话把吃掉的那个减掉。用set维护。

 1 #include <bits/stdc++.h>
 2 #define ll long long
 3 using namespace std;
 4 const int N = 1e5+10;
 5 typedef pair<ll, ll> P;
 6 vector<P> vs[N];
 7 bool vis[N];
 8 set<P> st;
 9 ll a[N], n, m, t;
10 int main() {
11     ios::sync_with_stdio(false);
12     cin >> t;
13     while(t--) {
14         cin >> n >> m;
15         for(int i = 1; i <= m; i ++) {
16             ll u, v, w;
17             cin >> u >> v >> w;
18             a[u] += w;
19             a[v] += w;
20             vs[u].push_back(P(v,w));
21             vs[v].push_back(P(u,w));
22         }
23         for(int i = 1; i <= n; i ++) {
24             st.insert(P(a[i], i));
25         }
26         ll ans = 0;
27         for(int i = 1; i <= n; i ++) {
28             ll u = st.begin()->second;
29             st.erase(st.begin());
30             ans = max(ans,a[u]);
31             vis[u] = 1;
32             for(int j = 0; j < vs[u].size(); j ++) {
33                 ll v = vs[u][j].first, w = vs[u][j].second;
34                 if(!vis[v]){
35                     st.erase(P(a[v],v));
36                     a[v] -= w;
37                     st.insert(P(a[v],v));
38                 }
39             }
40         }
41         cout << ans << endl;
42         for(int i = 1; i <= n; i ++) {
43             vs[i].clear();
44         }
45         st.clear();
46         memset(vis, 0, sizeof(vis));
47         memset(a, 0, sizeof(a));
48     }
49     return 0;
50 }

G 命名规范问题

题目描述

驼峰命名法是起变量名的一种规范，大致来说是用混合的大小写字母来构成变量名，在这个问题里你可以假设具体规则如下：

1.每个变量名由至少2个单词拼接构成，且每个单词长度至少为2；

2.每个单词的首字母必须大写，其他位置必须小写（除了变量名的第一个单词允许全部小写外）。

 

但是SK同学的英语很差，看到长长的变量名就很难脑补出是由哪些单词组成的，因此看驼峰命名法的代码十分头疼。

还有一种下划线命名法，规则比较简单，即各个单词之间用下划线‘_‘连接，且字母全部小写。

现在给你一些变量名，你能将其中符合驼峰命名法规范的变量转换成下划线命名法吗？

 

输入描述:

第一行是一个正整数T(≤ 20000)，表示测试数据的组数，
每组测试数据只有一行，包含一个仅包含大小写英文字母且长度不超过20的变量名，
保证所有测试数据变量名长度总和不超过200000。

输出描述:

对于每组测试数据，输出一行，包含一个字符串，如果变量名符合驼峰命名法规范则将其改为下划线命名法，否则不变。

示例1

输入

10
mystring
myString
String
SS
my
mySString
mString
STRING
StrinG
IndexOfString

输出

mystring
my_string
String
SS
my
mySString
mString
STRING
StrinG
index_of_string


模拟题，两个大小字母在一起，最后一个字母是大写，只有一个单词 都不符合驼峰命名法规范，直接输出。其它就转换下。

 1 #include <bits/stdc++.h>
 2 #define ll long long
 3 using namespace std;
 4 
 5 int main() {
 6     int t;
 7     cin >> t;
 8     string s;
 9     while(t--) {
10         cin >> s;
11         bool flag = true;
12         int index = 0, ans = 1;
13         for(int i = 1; i < s.length(); i ++) {
14             if(s[i] >= ‘A‘ && s[i] <= ‘Z‘ && i == index + 1) {
15                 flag = false;
16                 break;
17             } else if(s[i] >= ‘A‘ && s[i] <= ‘Z‘) index = i, ans++;
18         }
19         if(ans == 1||!flag || (index==s.length()-1)) cout << s << endl;
20         else {
21             for(int i = 0; i < s.length(); i ++) {
22                 if(s[i] >= ‘A‘ && s[i] <= ‘Z‘ && i != 0) {
23                     printf("_%c",s[i]+32);
24                 } else if(s[i] >= ‘A‘ && s[i] <= ‘Z‘ && i == 0){
25                     printf("%c",s[i]+32);
26                 }else cout << s[i];
27             }
28             cout << endl;
29         }
30     }
31     return 0;
32 }

I 如何办好比赛

题目描述

又到了一年一度的程序设计大赛了~

 

现在参赛选手在机房前排起了一列长队，这里面有萌新也有大佬，萌新都很仰慕大佬，由于大佬们的参赛，萌新们对这次比赛的精彩程度格外期待。对于每个萌新来说，他/她/它对本次的比赛的期待度为排在他/她/它前面的大佬的数量，而这次比赛的总期待度等于每个萌新的期待度之和。

 

SK同学作为本次比赛的组织者，希望比赛的期待度能够刚刚好，太低的话会让大家兴致不高，太高的话会被喷不满足预期。

 

现在SK同学可以交换任意相邻的两名参赛选手，但是比赛马上就要开始了，SK同学想知道最少要进行多少次交换才能使得这次比赛的总期待度刚好为k，你能帮帮他吗？

输入描述:

第一行是一个正整数T(≤ 10)，表示测试数据的组数，
对于每组测试数据，
第一行是两个正整数n(≤ 1000000)和k(≤ 1000000000)，分别表示队列长度和最终的比赛总期待度，
接下来一行包含n个字符，表示这个队列，第i个字符表示队列里的第i个人，‘D‘表示大佬，‘M‘表示萌新，保证不会出现其它字符。

输出描述:

对于每组测试数据，输出一行，包含一个整数，表示最少的交换次数，无解输出-1。

示例1

输入

2
3 1
DMM
3 3
DMM

输出

1
-1

先计算当前期待度是多少，答案就是他们的差了。

 1 #include <bits/stdc++.h>
 2 #define ll long long
 3 using namespace std;
 4 const int N = 1000010;
 5 char str[N];
 6 ll a[N];
 7 int main() {
 8     int t;
 9     cin >> t;
10     while(t--) {
11         ll n, k, ans = 0;
12         cin >> n >> k;
13         cin >> str+1;
14         for(int i = 1; i <= n; i ++) {
15             if(str[i] == ‘D‘) {
16                 a[i] = 1;
17                 ans ++;
18             }
19             a[i] += a[i-1];
20         }
21         if(ans*(n-ans) < k) printf("-1\n");
22         else{
23             ll cnt = 0;
24             for(int i = 1; i <= n; i ++) {
25                 cnt += str[i]==‘M‘?a[i]:0;
26             }
27             cout << abs(k-cnt) << endl;
28         }
29         memset(a,0,sizeof(a));
30         memset(str,0,sizeof(str));
31     }
32     return 0;
33 }