#19ACM第五次周赛补题赛de题解呐#

1
2
3
4
5
6
#include<stdio.h>
int main(){
printf("Accepted！!!");
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
描述:
Fenoix觉得xxx是一个非常怪的人，因为他特别厌恶xxx这样的人。
现在他给你出一道有关xxx的题目，让你去把xxx消灭了。
如果一个文件名中一行包含三个或更多“x”（小写拉丁字母“x”），则他需要你把存在xxx的情况去除。
他给出的文件名中要求你删除的最少字符数，以便在文件名之后不再包含“xxx”作为子字符串。
如果文件名最初不包含禁止的子字符串“xxx”，则打印0。
您可以删除任意位置的字符（不一定是连续的）。如果删除一个字符，则字符串的长度将减少1。
例如，如果从字符串“exxxll”中删除从左到右第2个位置中的字符，则得到的字符串是“exxII”。
Fenoix说这个可是送分题哟~
输入:
第一行包含整数n（3≤n≤100）-表示文件名的长度。
第二行包含一个长度为n的字符串，该字符串仅由小写拉丁字母（文件名）组成。
输出:
打印要从文件名中删除的最小字符数，使文件名后面不包含“xxx”作为子字符串。
如果文件名最初不包含禁止的子字符串“xxx”，则打印0。
输入样例 1
输出样例 1
6
1
xxxiii

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
#include<stdio.h>
int main()
{
int i,j,n,m=0,num=0,sum=0;
char s[10005];
scanf("%d",&n);
scanf("%s",s);
i=m;
while(i<n)
{
num=0;
if(s[i]=='x')
{
num+=1;
for(j=i+1;j<n;j++)
{
if(s[j]=='x')
{
num+=1;
if(j==n-1)
{
sum+=num-2;
break;
}
}
else if(s[j]!='x')
{
if(num==3)
{
sum+=1;
}
else if(num>3)
{
sum+=num-2;
}
break;
}
}
i=j;
}
else
{
i=i+1;
}
}
printf("%dn",sum);
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
描述
lwm学姐决定为她的木屋做一个新的屋顶，他有n个矩形木板，编号从1到n。度为1，
高度为第i个木板的尺寸为ai×1(即宽ai)。现在，lwm学姐想做一个方形屋顶。
他先挑选一些厚木板，把它们按一定的顺序并排放在一起。然后他会把这些木板的垂直边粘在一起。
最后，他将从最终形状中切出一个正方形,使正方形的边长是水平和垂直的。
例如，如果lwm学姐有长度为4、3、1、4和5的木板，他可以选择长度为4、3和5的木板。
然后他可以切出一个3×3的正方形，这是最大的可能。注意，这不是他得到3×3正方形的唯一方法。
lwm学姐能得到的最大边长是多少?
输入:
输入的第一行包含一个整数k(1≤k≤10)，即输入的测试用例的数量。
对于每个测试用例，第一行包含一个整数n(1≤n≤1000)，lwm学姐存储的木板数量。
下一行包含n个整数a1，…，an(1≤ai≤n)，即板材的长度。
输出:
对于每个测试用例，输出一个整数，即正方形的最大可能边长。
输入样例 1
输出样例 1
4
3
5
4
4 3 1 4 5
1
4
3
4 4 4 4
3
1 1 1
5
5 5 1 1 5

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
#include<stdio.h>
#include<algorithm>
using namespace std;
#define hhh 100005
int a[hhh];
bool cmp(int b,int c){
return b>c;
}
int main(){
int k,n;
scanf("%d",&k);
while(k--){
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
}
sort(a,a+n,cmp);
int sum=1;
for(int i=0;i<n;i++){
if(a[i]==sum){
printf("%dn",sum);
break;
}
else if(a[i]<sum){
printf("%dn",sum-1);
break;
}
sum++;
}
}
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
描述:
Fenoix非常喜欢看足球，又超喜欢把生活中的事情与学习和算法联系起来。一天，当他正在看
足球比赛时，他正在一张纸上写下球员们目前的位置。于是就想了一道题目来为难作为新生的你。
为了简化这种情况，他把它描绘成一个由0和1组成的字符串。
0对应一个队的队员；1对应另一个队的队员。如果一个队中至少有7名队员一个接一个地站着，
那么这种情况就被认为是危险的。例如，情况00110111111101是危险的，而11110111011101不是。
现在的情况是这样的,需要你确定它是否危险。
输入:
第一个输入行包含一个由字符“0”和“1”组成的非空字符串。
字符串的长度不超过100个字符。
每个队至少有一名队员在场。
输出:
如果情况危险，请打印"YES"。否则，打印"NO"。
输入样例 1
输出样例 1
001001
NO
输入样例 2
输出样例 2
1000000001
YES

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
#include<string.h>
int main(){
char a[100005];
scanf("%s",a);
int l=strlen(a);
for(int i=0;i<l;i++){
if(a[i]-'0'==0){
if(a[i+1]-'0'==0&&a[i+2]-'0'==0&&a[i+3]-'0'==0&&a[i+4]-'0'==0&&a[i+5]-'0'==0&&a[i+6]-'0'==0){
printf("YESn");
break;
}
}
else{
if(a[i+1]-'0'==1&&a[i+2]-'0'==1&&a[i+3]-'0'==1&&a[i+4]-'0'==1&&a[i+5]-'0'==1&&a[i+6]-'0'==1){
printf("YESn");
break;
}
}
if(i==l-1){
printf("NOn");
}
}
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
描述
你有一个由n个整数组成的数组。你的任务是找出给定数组的递增子数组的最大长度。
子数组是数组中连续元素的序列。如果子数组的每个元素严格大于前一个元素，则称为递增子数组。
输入
第一行包含单个正整数n(1≤n≤10^5)，表示整数的数量。
第二行包含n个正整数a1 a2…， an(1≤ai≤10^9)。
输出
输出给定数组的递增子数组的最大长度。
输入样例 1
输出样例 1
5
3
1 7 2 11 15
输入样例 2
输出样例 2
6
1
100 100 100 100 100 100
输入样例 3
输出样例 3
3
3
1 2 3

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
#include<stdio.h>
long long a[100005],b[100005];
int main(){
long long n,i=0,num=1,j=0;
scanf("%lld",&n);
for(long long i=0;i<n;i++){
scanf("%lld",&a[i]);
}
for(long long i=1;i<n;i++){
if(a[i-1]<a[i]){
num+=1;
}
else{
b[j]=num;
j+=1;
num=1;
}
if(i==n-1){
b[j]=num;
}
}
long long maxx=0;
for(long long k=0;k<j+1;k++){
if(b[k]>=maxx){
maxx=b[k];
}
}
printf("%lldn",maxx);
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
描述:
总所周知cgy学长特别喜欢吃糖果，而且他吃糖果有一个习惯，就是他每次会吃两颗糖果，而且
两颗糖果必须是不同口味的，否则他就不会吃。现在他有一些糖果，请问他能把这些糖果吃完吗？
输入:
第一行一个整数T，代表T组输入
每组输入第一行一个整数n，代表cgy学长有n种不同口味的糖果
接下来n个整数a1，a2，a3，……，an，表示每种口味的糖果有ai个
0<T<=10，0<n<=1000000，0<ai<=1000
输出:
如果cgy学长能把所有的糖果吃完，输出"NICE!!!",否则输出"****!!!"。
输入样例 1
输出样例 1
3
NICE!!!
3
NICE!!!
1 2 1
****!!!
4
2 2 2 2
4 1 5 2 1

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
#include<stdio.h>
#include<algorithm>
using namespace std;
bool cmp(int c,int d){
return c>d;
}
int main(){
int t,n;
int a[100005];
scanf("%d",&t);
while(t--){
int m=0,sum=0;
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
sum+=a[i];
}
sort(a,a+n,cmp);
if(sum%2==1){
printf("****!!!n");
}
else if(sum%2==0){
if(a[0]<=(sum/2)){
printf("NICE!!!n");
}
else{
printf("****!!!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
描述:
LJN学长很想知道你们学了的知识，是不是都掌握了。
学校的小礼堂每天都会有许多活动，有时间这些活动的计划时间会发生冲突，需要选择出
一些活动进行举 办。小刘的工作就是安排学校小礼的活动，每个时间最多安排一个活动。
现在小刘有一些活动计划的时间 表，他想尽可能的安排更多的活动，请问他该如何安排。
题目很熟悉吧，那还不赶紧ac！！！
输入:
第一行是一个整型数m(m<100)表示共有m组测试数据。
每组测试数据的第一行是一个整数n(1<n<10000)表示该测试数据共有n个活动。
随后的n行，每行有两个正整数Bi,Ei(0<=Bi,Ei<10000),分别表示第i个活动的起始
与结束时间（Bi<=Ei)
输出:
对于每一组输入，输出最多能够安排的活动数量。
每组的输出占一行
输入样例 1
输出样例 1
2
1
2
2
1 10
10 11
3
1 10
10 11
11 20

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
#include<stdio.h>
#include<algorithm>
using namespace std;
struct hhh
{
int b;
int e;
}v[10005];
bool cmp(hhh a,hhh c)
{
if(a.e==c.e)
{
return a.b>c.b;
}
return a.e<c.e;
}
int main()
{
int m,n,s,sum;
scanf("%d",&m);
while(m--){
scanf("%d",&n);
sum=1;
for(int i=0;i<n;i++){
scanf("%d %d",&v[i].b,&v[i].e);
}
sort(v,v+n,cmp);
s=v[0].e;
for(int i=1;i<n;i++){
if(v[i].b>s){
sum++;
s=v[i].e;
}
}
printf("%dn",sum);
}
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
描述:
Fenoix喜欢跟字符串玩耍，他发现新生最近刚刚学会了栈和队列，于是，他又来刁难学弟了。
他要求将一个字符串x插入另一个字符串y中（包括放在开头和结尾）
他定义的一个字符串是好串：
一开始，有一个空串，然后执行0次或者若干次操作，每次操作将ab插入当前的字符串。
根据上面的定义可知，ab, aabb, aababb都是好串，而aab,ba,abbb并不是好串。
现在给你一个字符串s，让你判断s是否是好串？
输入:
输入一行包含一个字符串,长度不超过50
输出:
输出"Good" 或者 "Bad"
输入样例 1
输出样例 1
ab
Good
输入样例 2
输出样例 2
aab
Bad
输入样例 3
输出样例 3
abaababababbaabbaaaabaababaabbabaaabbbbbbbb
Bad

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
#include<bits/stdc++.h>
#include<stack>
using namespace std;
int main(){
char a[10005];
stack<char>q;
scanf("%s",a);
int l=strlen(a);
if(a[0]=='a'&&a[l-1]=='b'){
q.push(a[0]);
for(int i=1;i<l;i++){
if(!q.empty()&&q.top()=='a'&&a[i]=='b'){
q.pop();
}
else{
q.push(a[i]);
}
}
if(!q.empty()){
printf("Badn");
}
else{
printf("Goodn");
}
}
else{
printf("Badn");
}
return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
描述:
又轮到Fenoix出题了，Fenoix表示出题太难了，于是他出了一道大水题，
说是为了增加学弟学妹们的体验，其实是为了划水。
给你一个数n，计算n！( n的阶乘 ) 。
输入:
第一行一个整数T（1<=T<=10），代表T组输入
每组输入一个整数 n（1<=n<=18），计算n！
输出:
输出n！的值
输入样例 1
输出样例 1
3
1
1
2
2
6
3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include<stdio.h>
int main(){
int t,n;
scanf("%d",&t);
while(t--){
long long ans=1;
scanf("%d",&n);
for(int i=1;i<=n;i++){
ans*=i;
}
printf("%lldn",ans);
}
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
描述:
lwm学姐快自闭了，看着学弟学妹们都快ak了，自己都还没做几道题，
于是她赶快找了一道水题提升自己的排名。
给你一个整数n，输出第n个斐波那契数。
斐波那契数满足a[ i ] = a[ i - 1 ] + a[ i - 2 ]，比如1，1，2，3，5，8……
输入:
第一行一个整数T，表示T组输入
接下来T行，每行一个整数n，表示第n个斐波那契数
1<=T<=10，1<=n<=90
输出:
对于每组输入输出第n个斐波那契数
输入样例 1
输出样例 1
5
1
1
2
3
5
5
13
7
34
9

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdio.h>
int main(){
int t,n;
long long a[100005];
scanf("%d",&t);
while(t--){
scanf("%d",&n);
a[1]=1;
a[2]=1;
for(int i=3;i<=n;i++){
a[i]=a[i-1]+a[i-2];
}
printf("%lldn",a[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
60
61
62
63
64
65
66
67
描述:
Fenoix老实说就是想针对你们出这道题目，让你们自闭。
打印如下有规律的矩阵；
n=5:
1
2
9 10 25
4
3
8 11 24
5
6
7 12 23
16 15 14 13 22
17 18 19 20 21
n=6:
1
2
9 10 25 26
4
3
8 11 24 27
5
6
7 12 23 28
16 15 14 13 22 29
17 18 19 20 21 30
36 35 34 33 32 31
输入:
多组输入，每次输入一个整数n。(n<100)
输出:
输出一个对应规律的矩阵。
每一个数按照%2d格式输出，并且每个数之间还要加一个空格。
最后每次输出答案要加多一行空行，为了好看。
请看提示。
输入样例 1
输出样例 1
5
1
2
9 10 25
6
4
3
8 11 24
5
6
7 12 23
16 15 14 13 22
17 18 19 20 21
1
2
9 10 25 26
4
3
8 11 24 27
5
6
7 12 23 28
16 15 14 13 22 29
17 18 19 20 21 30
36 35 34 33 32 31
提示:
注意输出格式：
printf("%2d ", p[i][j]);
%2d:按宽为2输出，右对齐方式输出，若不够两位，左边补空格。

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
#include<bits/stdc++.h>
using namespace std;
#define hhh 1005
int a[hhh][hhh];
int main(){
int n,m;
while(~scanf("%d",&n)){
a[0][0]=1;
for(int i=1;i<n;i++){
a[i][i]=a[i-1][i-1]+2*i;
}
for(int j=1;j<n;j++){
m=j;
if(j%2==0){
while(m--){
a[m][j]=a[m+1][j]+1;
a[j][m]=a[j][m+1]-1;
}
}
else{
while(m--){
a[m][j]=a[m+1][j]-1;
a[j][m]=a[j][m+1]+1;
}
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
printf("%2d ",a[i][j]);
}
printf("n");
}
printf("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
描述:
Fenoix喜欢去思考一些不着边际的东西，特别是人类的来源，宇宙的由来，等等。
有一天晚上，他想了一个有趣的事情，它想起了平行宇宙，如果它真的存在，那么
这个宇宙中还会有另一个自己，这是多么有趣的事情呀~
于是他又搞怪起来了，他不想让宇宙中有其相同的两个人存在。
于是简单的说就是有一个宇宙，宇宙中有很多人，他想去掉相同的人。
1.给出一个整数n，n代表数组a中有多少元素。
2.想去掉重复的（相等的）元素。
3.只想保留数组的每个元素，是从数组最右边第一次出现的元素。
4.要求不能更改其余唯一元素的相对顺序。
输入:
第一行包含一个整数n（1≤n≤50）-n代表数组中的元素个数。
下一行包含序列a1，a2，…，an（1≤ai≤1000）-数组中的元素。
输出:
在第一行中，让你按他要求删除重复项后，留在数组中的元素个数x。
在第二行中，打印x个整数，这些整数在你删除重复项后输出时，必须用空格将元
素分隔开，末尾有无空格都对。
按要求输出结果，请看下列注意。
输入样例 1
输出样例 1
6
3
1 5 5 1 6
1
5 6 1
输入样例 2
输出样例 2
5
2
2 4 2 4 4
2 4
输入样例 3
输出样例 3
5
1
6 6 6 6 6
6
提示:
注意
在第一个示例中，您应该删除位于位置1和位置4的两个整数1。此外，还应该删除
位于位置2的整数5。
在第二个示例中，您应该删除位于位置1的整数2和位于位置2和4的两个整数4。
在第三个示例中，您应该删除位于位置1，2，3和4位置的两个整数6。

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
#include<bits/stdc++.h>
using namespace std;
#define hhh 100005
int a[hhh];
bool s[hhh];
int main(){
int n,ans=0;
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
}
for(int i=n-1;i>=0;i--){
if(s[a[i]]){
a[i]=0;
}
else{
ans+=1;
s[a[i]]=true;
}
}
printf("%dn",ans);
for(int i=0;i<n;i++){
if(a[i]){
printf("%d ",a[i]);
}
}
return 0;
}