浙江农林大学蓝桥杯程序设计竞赛校选拔赛（同步赛）签到题ABFGHIJ
A. uu与糖果
链接：https://ac.nowcoder.com/acm/contest/12479/A
来源：牛客网
题目描述
uu是一个伟大的魔法师，她有n堆糖果。
由于她想得到更多的糖果，她可以施展无数次魔法，魔法的效果是她可以选择任意一堆糖果，使得那堆糖果的数量增加h，如果有任何一堆糖果的数量在施展魔法后超过了k，uu就会永远失去释放魔法的能力。
uu想知道她最多能得到多少颗糖果？
输入描述:
每组输入的第一行为n(1 <= n <= 2e6), k(1 <= k <= 1e9), h(0 <= h <= 1e9).
接下来一行为n个数字，代表每堆糖果的数量ai(1 <= ai <= 1e9)
输出描述:
输出一个整数，代表uu能得到最多糖果的数量。
示例1
输入
复制
3 9 1
1 3 5
输出
复制
28
示例2
输入
复制
3 4 2
1 5 2
输出
复制
14
/*
题意：n个数字，每次加h，可以加任意次。只要有一个数字被加后超过k就不能加了，求最后数字总和的最大值。
思路：注意是被加后超过k，如果初始超过k，还以加其他数字的。直接把每个数字加到刚好小于等于k，即x和k的差值对h整除。最后加上k即可。
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 2e6+10;
LL a[maxn];
int main(){
LL n, h, k;
while(cin>>n>>h>>k){
LL ans = 0;
for(int i = 1; i <= n; i++){
LL x; cin>>x;
if(x>h){
ans += x;
continue;
}
if(k != 0){
LL t = (LL)(h-x)/k;
ans += x+t*k;
}else{
ans += x;
}
}
ans += k;
cout<<ans<<"\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
B. 蒟蒻wzc与方块涂色
链接：https://ac.nowcoder.com/acm/contest/12479/B
来源：牛客网
题目描述
蒟蒻wzc最近碰到了一道简单题，但是他实在是太弱了，怎么也做不出。
他非常得生气于是把这道题略微强化了一下拿出来考验大家。
现在wzc手上有一个边长为n(n>1)的由小方块组成的立方体。他现在对这个立方体方块棱边上的小方块进行涂色，最开始的时候所有小方块都是白色的，现在他会把一些小方块涂成黑色。
如果他对某一个小方块涂色，就会把这个小方块露在外面的所有部分都涂黑，比如顶角上的小方块露在外面的共有三面，如果对这个小方块涂色，wzc会把露出来的三面全部涂成黑色，而不是只涂其中一面或者两面。
如下图以n=3的立方体为例，现在把立方体的12条棱边用1-12的数字进行标记。
现在wzc希望把这12条棱边上，a1,a2,a3,…,a12个小方块涂成黑色。（ai代表编号为i的棱边上有ai个方块被涂成黑色）
他希望你可以帮他判断，是否存在涂色的方案，可以满足上述对每条棱上涂黑个数的要求。
输入描述:
第一行为一个整数t,代表测试数据组数。（1<=t<=1000）
接下来t行为t组测试数据，每组数据一行。
每组数据包含用空格隔开的13个整数，第一个整数为n，代表立方体每条棱边上有几个小方块，接下来为12个整数a1,a2,…,a12分别代表按题面图片所标记的12条棱边上各自有多少个方块被涂成了黑色。
（2<=n<=10,0<=ai<=n)
输出描述:
输出T行，每组测试数据对应输出一行。
如果存在满足的涂色方案，输出"YES"，否则输出"NO"。
示例1
输入
复制
3
3 3 3 3 3 3 3 3 3 3 3 3 3
3 3 3 3 2 3 3 3 3 3 3 3 3
3 3 3 3 1 3 3 3 3 3 3 3 3
输出
复制
YES
YES
NO
说明
第一组数据把所有棱边上的小方块均涂黑即可。
第二组数据把除了第4条棱边上的所有小方块均涂黑，第4条棱边中间的小方块不涂黑即可。
第三组数据不存在满足的涂色方案。
/*
题意：给出一个n*n*n的立方体，以及12条边相邻面有几个涂黑了。求是否存在满足条件的涂色方案。
思路：对于每条边中间的n-2个面不会影响到其他结果，所以只需要考虑8个棱角的面涂还是不涂。直接枚举所有可行的结果，然后暴力判断是否小于a[i]，且+(n-2)大于a[i]即可。
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL mod = 1000000007;
const int maxn = 10010;
int n, a[14], b[14], ok;
int id[8][3] = {{7,4,1},{6,7,8},{8,9,11},{1,2,11},{3,4,5},{5,6,10},{9,10,12},{2,3,12}};
void dfs(int cur){
if(cur == 8){
for(int i = 1; i <= 12; i++)
if(b[i]>a[i] || b[i]+n-2<a[i])return ;
ok = 1;
return ;
}
b[id[cur][0]]++;
b[id[cur][1]]++;
b[id[cur][2]]++;
dfs(cur+1);//涂
b[id[cur][0]]--;
b[id[cur][1]]--;
b[id[cur][2]]--;
dfs(cur+1);//不涂
return ;
}
int main(){
ios::sync_with_stdio(false);
int T; cin>>T;
while(T--){
cin>>n;
for(int i = 1; i <= 12; i++)cin>>a[i];
ok = 0;
dfs(0);
if(ok==1)cout<<"YES\n";
else cout<<"NO\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
F. 签不上到？做这题就对了
链接：https://ac.nowcoder.com/acm/contest/12479/F
来源：牛客网
题目描述
给你一个整数，你可以选择操作一次（也可以不操作）交换该数字中任意两位上的数字，使你的结果数尽可能大。
输入描述:
第一行输入一个T，代表测试的数据个数(T<=1000)
接下来T行,每行输入一个整数a (0<a<=1e8)
输出描述:
对于输入的T组样例，每一组输出一行你的结果数
示例1
输入
复制
1
1234
输出
复制
4231
说明
显然交换1，4位置上的数字会使结果数最大
/*
题意：给出一个整数，交换任意两位数字（只有一次操作），使结果尽可能大。
思路：
+ 找当前数字后面所有数中最大的那个跟他交换，如果没有比当前大的就去找下一个数字，如果有多个就交换最靠后的一个。
+ 维护mx[i]表示从i开始到最后的最大数字，cur[i]表示那个数字的最靠后的位置，从后往前扫一遍统计，然后从前往后枚举遇到不一样的交换一下就是答案了。
*/
#include<bits/stdc++.h>
using namespace std;
int main(){
int T; cin>>T;
while(T--){
string s; cin>>s;
int n = s.size();
string mx(n,'0');
vector<int>cur(n);
for(int i = n-1; i >= 0; i--){
mx[i] = s[i];
cur[i] = i;
if(i+1!=n && mx[i+1]>s[i]){
mx[i] = mx[i+1];
cur[i] = cur[i+1];
}else if(i+1!=n && mx[i+1]==s[i]){
cur[i] = cur[i+1];
}
}
//cout<<mx<<"\n";
//cout<<cur<<"\n";
for(int i = 0; i < n; i++){
if(mx[i]!=s[i]){
swap(s[i],s[cur[i]]);
break;
}
}
cout<<s<<"\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
G. 来上数学课
链接：https://ac.nowcoder.com/acm/contest/12479/G
来源：牛客网
题目描述
给出n个连续的题目，已知小明答对了m题。求小明所获得的最低分数是多少？
计分 规则：当答对一题的时候总分加一，同时计分器的分数加一。当答错时，
计分器清零，且总分不改变。但连续答对k题时，也就是计分器分数达到k分时，选手的总分加倍。
当然，是先将第k题的一分加上去后，总分才加倍， 同时计分器清零。
答案对1e9+9取余。
输入描述:
每行三个整数 n, m 和 k (2 ≤ k ≤ n ≤ 1e9; 0 ≤ m ≤ n).
输入不唯一
输出描述:
每行一个整数，代表最低分数。
示例1
输入
复制
6 5 2
输出
复制
13
说明
显然，错误的题目是第6题的时候，分数变化为 1->4->5->12->13->13
备注:
注意，令mod = 1e9 + 9， 这时（mod * 2 + 3）%mod 小于(mod + 4) % mod, 但是答案要取（mod + 4）% mod.
也就是说我们要找的是最低的总分，而不是取模后的值最小。
/*
题意：n个题，答对一题总分加一分，计分器同时加一且累加到k时候总分翻倍（错了就为零）。已知答对m题，求最低得分。
思路：错了w=n-m题，计分器最多可以拿[n/k]次，如果w>[n/k]表示可以卡着，那就m分。否则卡着最少也得拿t=n/k-w次，拿了的(2^(t+1)-2)*k分，没拿的m-t*k分。
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL mod = 1e9+9;
const int maxn = 10010;
LL mpow(LL a, LL x) {
if(x==0)return 1;
LL t = mpow(a, x>>1);
if(x%2==0)return t*t%mod;
return t*t%mod*a%mod;
}
int main(){
ios::sync_with_stdio(false);
int n, m, k;
while(cin>>n>>m>>k){
int w = n-m;
if(w >= n/k){cout<<m<<"\n"; continue;}
int t = n/k-w;
LL ans = (mpow(2,t+1)-2)*k+m-t*k;
ans = (ans+mod)%mod;
cout<<ans<<"\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
H. 蒟蒻wzc的填数游戏
链接：https://ac.nowcoder.com/acm/contest/12479/H
来源：牛客网
题目描述
蒟蒻wzc在学习最基本的算法知识内容，今天老师布置了一个简单的任务给他:
从一个nn的方格矩阵左上角的[1][1]出发，给定n-1次操作，每次移动只能到当前位置上下左右其中一个相邻位置（'w’代表向上走，'a’代表向左走，'s’代表向下走，'d’代表向右走），依次填下1到nn这n*n个数字。wzc的任务是输出填数后的矩阵是什么样子。
好家伙怎么这么难，wzc把求助的目光投向了你。
输入描述:
第一行为一个整数t代表样例数。（1<=t<=10）
每组样例包括两行，
每组样例的第一行为一个整数n，代表方格矩阵的边长。（2<=n<=6）
每组样例的第二行为一个长度为nn-1的字符串，对应nn-1次移动操作，只包含’w’‘a’‘s’'d’四种字符。（'w’代表向上走，'a’代表向左走，'s’代表向下走，'d’代表向右走）
题目保证nn-1次操作没有走出矩阵外，也没有重复走到同一个位置，也就是说nn-1次操作后，所有格子都会被填上一个数字。
输出描述:
对于每组样例，输出填数完成后的矩阵。
每行的数字之间用空格隔开。
每组样例之间用一个空行隔开。
示例1
输入
复制
2
3
ssddwawd
4
dsdwdsssawasaww
输出
复制
1 8 9
2 7 6
3 4 5
1 2 5 6
16 3 4 7
15 12 11 8
14 13 10 9
/*
题意：给出一个n*n的空矩阵，从(1,1)开始出发，按照给定的顺序移动并填数，填完输出即可。
思路：直接模拟。
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int maxn = 2e6+10;
int ch[20][20];
int main(){
int T; cin>>T;
while(T--){
int n; cin>>n;
string s; cin>>s;
memset(ch,0,sizeof(ch));
int x = 1, y = 1;
int tot = 1;
for(int i = 0; i < s.size(); i++){
ch[x][y] = tot++;
if(s[i]=='a'){y--;}
else if(s[i]=='d'){y++;}
else if(s[i]=='w'){x--;}
else if(s[i]=='s'){x++;}
}
ch[x][y] = tot;
for(int i = 1; i <= n; i++){
for(int j = 1; j <= n; j++){
cout<<ch[i][j]<<" ";
}
cout<<"\n";
}
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
I. 集训队长魂牵梦绕的题目
链接：https://ac.nowcoder.com/acm/contest/12479/I
来源：牛客网
题目描述
（现任zafu集训队队长wzc在他初学ACM时写到一道经典好题，一直想着什么时候个人赛拉过来让大家写一写。可惜当时的他没有整理代码记录题目题号的习惯，导致一直找不到那道题在哪。
现在他借由这次出题机会依靠回忆出了这道题，来了却这桩萦绕了许久的心事。）
因为Lucifer糟糕的脾气和行事风格，他的挚友Sariel再也无法忍受他，躲进了堕天使花园的最深处。
堕天使花园是一个2行n列的方格矩阵，Sariel躲在了最深处，右下角的[2][n]处。
Lucifer从左上角[1][1]出发，试图走到Sariel所在的位置向他道歉。
Lucifer每次移动只能移动到当前位置上下左右四个相邻的格子上，且不能走出矩阵外。
可是堕天使花园里不是所有的格子都是安全的，有一部分格子踩上去会使Lucifer失去对自己灵魂的控制，因此他决不能踩到这些格子上。
也就是说，很有可能Lucifer无法走到Sariel面前道歉。
可是由于Sariel有时候会由于心软，会将某个不安全的格子变成安全的，有时候也会由于不想见Lucifer，会把某个安全的格子变成不安全的。(每次修改的结果都会对后续造成影响）
你需要告诉Lucifer，初始的时候以及Sariel每次对堕天使花园修改后，Lucifer能否能否走到Sariel面前道歉。
（题目保证，任意时刻[1][1]和[2][n]位置都是安全的，即Lucifer所在的初始位置和Sariel所在的位置都是安全的）
输入描述:
第一行为一个正整数n，代表堕天使花园矩阵有几列。（1<=n<=1e6）
接下来第二行为n个空格隔开的整数a1,a2,…,an。（ai只可能为0或1，代表矩阵[1][i]位置是安全还是不安全，0代表安全，1代表不安全）
接下来第三行为n个空格隔开的整数b1,b2,…,bn。（bi只可能为0或1，代表矩阵[2][i]位置是安全还是不安全，0代表安全，1代表不安全）
第四行为一个整数m，代表Sariel会对堕天使花园做几次修改。（0<=m<=1e6）
接下来m行，每行为两个被空格隔开的整数x和y，代表位置[x][y]的格子被修改，如果该格子是安全的则被修改为不安全的，如果该格子是不安全的则被修改为安全的。
（1<=x<=2，1<=y<=n）
输出描述:
输出m+1行，第一行对应初始情况，2到m+1行对应m次修改后的情况。
每种情况，如果Lucifer能成功走到Sariel面前道歉，输出"I’m the worst friend.Please forgive me."
如果Lucifer无法走到Sariel面前道歉，输出"You are the worst friend."
示例1
输入
复制
4
0 0 0 0
0 0 0 0
7
1 2
2 2
1 3
2 3
2 3
1 2
1 3
输出
复制
I’m the worst friend.Please forgive me.
I’m the worst friend.Please forgive me.
You are the worst friend.
You are the worst friend.
You are the worst friend.
You are the worst friend.
You are the worst friend.
I’m the worst friend.Please forgive me.
说明
初始地图为
0 0 0 0
0 0 0 0
第一次修改后变为
0 1 0 0
0 0 0 0
第二次修改后变为
0 1 0 0
0 1 0 0
第三次修改后变为
0 1 1 0
0 1 0 0
第四次修改后变为
0 1 1 0
0 1 1 0
第五次修改后变为
0 1 1 0
0 1 0 0
第六次修改后变为
0 0 1 0
0 1 0 0
第七次修改后变为
0 0 0 0
0 1 0 0
示例2
输入
复制
4
0 1 0 0
0 0 1 0
6
2 2
1 3
2 3
2 3
1 2
1 3
输出
复制
You are the worst friend.
You are the worst friend.
You are the worst friend.
You are the worst friend.
You are the worst friend.
You are the worst friend.
I’m the worst friend.Please forgive me.
/*
题意：给出一个2*n的矩阵，0表示可走，1表示不可走。m次操作每次修改(x,y)为相反数。求每次操作后判断能否从(1,1)走到(2,n)。
思路：容易发现不可行的情况，对于a[i]=1时，b[i-1,i,i+1]都必须为0才能通过。开始傻了每次修改完去枚举，然而实际只要开个变量维护每次修改后和上次相比是否出现新的不成立状况即可。
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL mod = 1000000007;
const int maxn = 1e6+10;
int a[maxn], b[maxn];
int main(){
ios::sync_with_stdio(false);
int n; cin>>n;
for(int i=1; i<=n; i++)cin>>a[i];
for(int i=1; i<=n; i++)cin>>b[i];
int cnt = 0;//开始不能走的情况有几格（后面维护即可）
for(int i=2; i<=n; i++){
if(a[i]==1){
if(b[i-1]==1)cnt++;
if(b[i]==1)cnt++;
if(b[i+1]==1)cnt++;
}
}
if(cnt==0)cout<<"I'm the worst friend.Please forgive me.\n";
else cout<<"You are the worst friend.\n";
int m; cin>>m;
for(int i=1; i<=m; i++){
int x, y; cin>>x>>y;
if(x==1){
if(a[y]==1){
if(b[y]==1)cnt--;
if(b[y-1]==1)cnt--;
if(b[y+1]==1)cnt--;
}else{
if(b[y]==1)cnt++;
if(b[y-1]==1)cnt++;
if(b[y+1]==1)cnt++;
}
a[y] = !a[y];
}else{
if(b[y]==1){
if(a[y]==1)cnt--;
if(a[y-1]==1)cnt--;
if(a[y+1]==1)cnt--;
}else{
if(a[y]==1)cnt++;
if(a[y-1]==1)cnt++;
if(a[y+1]==1)cnt++;
}
b[y] = !b[y];
}
if(cnt==0)cout<<"I'm the worst friend.Please forgive me.\n";
else cout<<"You are the worst friend.\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
- 57
- 58
- 59
J. 消消乐
链接：https://ac.nowcoder.com/acm/contest/12479/J
来源：牛客网
题目描述
n颗任意颜色的珠子摆成一排，现在你知道每个珠子的颜色种类以及珠子的总数目。
现在你有一颗颜色为x的珠子。你可以将这颗珠子插在这一排珠子中的任意位置，
一旦存在连续的相同颜色的珠子数目大于等于三颗，那么这些连续的珠子将被消除。
同时两边的珠子向中间靠拢，将被消除的部分填满，这个过程不改变珠子的相对顺序。
保证初始状态不存在连续的同颜色珠子的数目大于等于三颗。
问：由你决定x的插入位置，问最多可以消除的珠子的数目是多少。（插入的珠子不计算在内）
输入描述:
第一行输入一个整数t, 代表测试数目。（1<=t<=20）
第二行输入三个正整数n (n <= 100) 、k（k <= 100）以及x (x <= k)。 分别代表珠子的总数目、珠子的颜色数
以及初始时所拥有的珠子的颜色。
第三行输入n个正整数C1,C2…Cn(Ci <= k )。
输出描述:
每行输出一个整数代表最大能消除的珠子的数量
示例1
输入
复制
1
10 2 1
2 1 2 2 1 2 2 1 1 2
输出
复制
5
说明
显然将颜色为1的珠子插在第8颗珠子的前面，珠子顺序变成2 1 2 2 1 2 2 2，消除3颗珠子
又形成3个连续的颜色为2的珠子， 珠子顺序变成2 1 2 2 1， 消除3颗珠子
不存在连续的同颜色的珠子数目大于等于3， 结束。 答案为3 + 3 - 1 = 5（减去插入的珠子）
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL mod = 1000000007;
const int maxn = 10010;
int xiao(vector<int>b, int h, int x){
b.insert(b.begin()+h,x);
//for(int v : b)cout<<v<<" "; cout<<"\n";
int tmp = 0, now = x;
int l = h-1, r = h+1;
while(1){
int cnt = 1;
while(l>=1 && b[l]==now){l--; cnt++;}
while(r<b.size() && b[r]==now){ r++; cnt++;}
if(cnt>=3)tmp += cnt;
else break;
if(l==0 && r==b.size())break;
if(l>=1){
now = b[l];
l--;
}else{
now = b[r];
r++;
}
}
//for(int v:b)cout<<v<<" ";cout<<"\n";
//cout<<tmp<<"\n";
return tmp;
}
int main(){
ios::sync_with_stdio(false);
int T; cin>>T;
while(T--){
int n, k, x; cin>>n>>k>>x;
int ans = 0;
vector<int>a(n+1);
for(int i = 1; i <= n; i++)cin>>a[i];
for(int i = 1; i <= n+1; i++){
int tmp = xiao(a,i,x);
ans = max(ans, tmp);
//cout<<tmp<<"\n";
}
if(ans !=0)cout<<ans-1<<"\n";
else cout<<"0\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
文章来源: gwj1314.blog.csdn.net，作者：小哈里，版权归原作者所有，如需转载，请联系作者。
原文链接：gwj1314.blog.csdn.net/article/details/114498326
- 点赞
- 收藏
- 关注作者
评论（0）