第一题 单位变换
题目
【问题描述】
在计算机存储中,15.125 GB是多少MB?
【答案提交】
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
思路
1GB=1024MB
答案
15488
第二题 约数个数
题目
【问题描述】
1200000 有多少个约数(只计算正约数)。
【答案提交】
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
思路
枚举+判断
答案
96
代码
#include <iostream>
using namespace std;
const int N = 1200000 ;
int main ( ) {
int ans = 0 ;
for ( int i = 1 ; i <= N; ++ i) {
if ( N % i == 0 )
ans++ ;
}
cout << ans << endl;
return 0 ;
}
第三题 叶结点数
题目
【问题描述】
一棵包含有2019 个结点的二叉树,最多包含多少个叶结点?
【答案提交】
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
思路
n0——叶子节点个数, n1——度为1的节点个数, n2——度为2的节点个数, n——总节点数
对任意二叉树有:n=n0+n1+n2,n0=n2+1
联立可得:n=n0+n1+n0-1=2*n0+n1-1
依题意:n=2019,为使叶子节点数n0最多,必须让n1最小,设为0,故而:
2*n0-1=2019, 解得n0=1010
答案
1010
第四题 数字9
题目
【问题描述】
在1 至2019 中,有多少个数的数位中包含数字9 ?
注意,有的数中的数位中包含多个9 ,这个数只算一次。例如,1999 这个数包含数字9 ,在计算时只是算一个数。
【答案提交】
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
答案
544
代码
#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
using namespace std;
string int_str ( int n)
{
string str;
stringstream Convert;
Convert<< n;
Convert>> str;
return str;
}
int main ( )
{
string str;
int count = 0 ;
for ( int i= 1 ; i<= 2019 ; i++ ) {
str = int_str ( i) ;
int position= str. find ( "9" , 0 ) ;
if ( position!= - 1 )
count+ = 1 ;
}
cout<< count<< endl;
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 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
第五题 数位递增的数
题目
【问题描述】
一个正整数如果任何一个数位不大于右边相邻的数位,则称为一个数位递增的数,例如1135 是一个数位递增的数,而1024 不是一个数位递增的数。
给定正整数 n,请问在整数 1 至 n 中有多少个数位递增的数?
【输入格式】
输入的第一行包含一个整数 n。
【输出格式】
输出一行包含一个整数,表示答案。
【样例输入】
30
【样例输出】
26
【评测用例规模与约定】
对于 40 % 的评测用例,1 <= n <= 1000 。
对于 80 % 的评测用例,1 <= n <= 100000 。
对于所有评测用例,1 <= n <= 1000000 。
思路
遍历 + 类型转换 + 判断
代码
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
string int_str ( int n)
{
string str;
stringstream Convert;
Convert<< n;
Convert>> str;
return str;
}
int main ( )
{
int n= 0 ;
cin>> n;
int count= 0 ;
for ( int i= 1 ; i<= n; i++ ) {
string str = int_str ( i) ;
int flag= 1 ;
for ( int j= 0 ; j< str. size ( ) - 1 ; j++ ) {
if ( str[ j] > str[ j+ 1 ] ) {
flag= 0 ;
break ;
}
}
if ( flag)
count++ ;
}
cout<< count<< endl;
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 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
第六题 递增三元组
题目
【问题描述】
在数列 a[ 1 ] , a[ 2 ] , …, a[ n] 中,如果对于下标 i, j, k 满足 0 < i< j< k< n+ 1 且 a[ i] < a[ j] < a[ k] ,则称 a[ i] , a[ j] , a[ k] 为一组递增三元组,a[ j] 为递增三元组的中心。
给定一个数列,请问数列中有多少个元素可能是递增三元组的中心。
【输入格式】
输入的第一行包含一个整数 n。
第二行包含 n 个整数 a[ 1 ] , a[ 2 ] , …, a[ n] ,相邻的整数间用空格分隔,表示给定的数列。
【输出格式】
输出一行包含一个整数,表示答案。
【样例输入】
5
1 2 5 3 5
【样例输出】
2
【样例说明】
a[ 2 ] 和 a[ 4 ] 可能是三元组的中心。
【评测用例规模与约定】
对于 50 % 的评测用例,2 <= n <= 100 ,0 <= 数列中的数 <= 1000 。
对于所有评测用例,2 <= n <= 1000 ,0 <= 数列中的数 <= 10000 。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
思路
先确定中间元素a[i],再分别判断a[i]左边和右边是否存在小于和大于它的数
代码
#include <iostream>
using namespace std;
int main ( )
{
int n= 0 ;
cin>> n;
int * a = new int [ n] ;
for ( int i= 0 ; i< n; i++ )
cin>> a[ i] ;
int count = 0 ;
for ( int i= 1 ; i< n- 1 ; i++ )
{
int flag_p= 0 , flag_b= 0 ;
for ( int j= 0 ; j< i; j++ )
{
if ( a[ j] < a[ i] )
{
flag_p= 1 ;
break ;
}
}
for ( int j= i+ 1 ; j< n; j++ )
{
if ( a[ j] > a[ i] )
{
flag_b= 1 ;
break ;
}
}
if ( flag_p& flag_b)
count++ ;
}
cout<< count<< endl;
delete [ ] a;
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 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
第七题 音节判断
题目
【问题描述】
小明对类似于 hello 这种单词非常感兴趣,这种单词可以正好分为四段,第一段由一个或多个辅音字母组成,第二段由一个或多个元音字母组成,第三段由一个或多个辅音字母组成,第四段由一个或多个元音字母组成。
给定一个单词,请判断这个单词是否也是这种单词,如果是请输出yes,否则请输出no。
元音字母包括 a, e, i, o, u,共五个,其他均为辅音字母。
【输入格式】
输入一行,包含一个单词,单词中只包含小写英文字母。
【输出格式】
输出答案,或者为yes,或者为no。
【样例输入】
lanqiao
【样例输出】
yes
【样例输入】
world
【样例输出】
no
【评测用例规模与约定】
对于所有评测用例,单词中的字母个数不超过100 。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
思路
将每一个元音元素记为1,辅音元素记为0
当首元素为辅音,尾元素为元音;且0,1变换出现3次则为yes,否则为no。
代码
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main ( ) {
string word;
cin>> word;
vector< int > vec;
for ( int i= 0 ; i< word. size ( ) ; i++ ) {
if ( word[ i] == 'a' || word[ i] == 'e' || word[ i] == 'i' || word[ i] == 'o' || word[ i] == 'u' )
vec. push_back ( 1 ) ;
else
vec. push_back ( 0 ) ;
}
int count = 0 ;
if ( vec[ 0 ] == 0 && vec[ vec. size ( ) - 1 ] == 1 ) {
for ( int i= 0 ; i< vec. size ( ) - 1 ; i++ ) {
if ( vec[ i] + vec[ i+ 1 ] == 1 )
count + = 1 ;
}
if ( count== 3 )
cout<< "yes" << endl;
else
cout<< "no" << endl;
}
else
cout<< "no" << endl;
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 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
第八题 长草
题目
【问题描述】
小明有一块空地,他将这块空地划分为 n 行 m 列的小块,每行和每列的长度都为 1 。
小明选了其中的一些小块空地,种上了草,其他小块仍然保持是空地。
这些草长得很快,每个月,草都会向外长出一些,如果一个小块种了草,则它将向自己的上、下、左、右四小块空地扩展,这四小块空地都将变为有草的小块。
请告诉小明,k 个月后空地上哪些地方有草。
【输入格式】
输入的第一行包含两个整数 n, m。
接下来 n 行,每行包含 m 个字母,表示初始的空地状态,字母之间没有空格。如果为小数点,表示为空地,如果字母为 g,表示种了草。
接下来包含一个整数 k。
【输出格式】
输出 n 行,每行包含 m 个字母,表示 k 个月后空地的状态。如果为小数点,表示为空地,如果字母为 g,表示长了草。
【样例输入】
4 5
. g. . .
. . . . .
. . g. .
. . . . .
2
【样例输出】
gggg.
gggg.
ggggg
. ggg.
【评测用例规模与约定】
对于 30 % 的评测用例,2 <= n, m <= 20 。
对于 70 % 的评测用例,2 <= n, m <= 100 。
对于所有评测用例,2 <= n, m <= 1000 ,1 <= k <= 1000 。
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 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
代码
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main ( ) {
int n= 0 , m= 0 ;
cin>> n>> m;
char ground[ n] [ m] ;
for ( int i= 0 ; i< n; i++ ) {
for ( int j= 0 ; j< m; j++ ) {
cin>> ground[ i] [ j] ;
}
}
char temp[ n] [ m] ;
for ( int i= 0 ; i< n; i++ ) {
for ( int j= 0 ; j< m; j++ ) {
temp[ i] [ j] = '.' ;
}
}
int k= 0 ;
cin>> k;
while ( k> 0 ) {
for ( int i= 0 ; i< n; i++ ) {
for ( int j= 0 ; j< m; j++ ) {
if ( ground[ i] [ j] == 'g' ) {
temp[ i] [ j] = 'g' ;
if ( i- 1 >= 0 )
temp[ i- 1 ] [ j] = 'g' ;
if ( i+ 1 < n)
temp[ i+ 1 ] [ j] = 'g' ;
if ( j+ 1 < m)
temp[ i] [ j+ 1 ] = 'g' ;
if ( j- 1 >= 0 )
temp[ i] [ j- 1 ] = 'g' ;
}
}
}
for ( int i= 0 ; i< n; i++ )
for ( int j= 0 ; j< m; j++ )
ground[ i] [ j] = temp[ i] [ j] ;
k- = 1 ;
}
for ( int i= 0 ; i< n; i++ ) {
for ( int j= 0 ; j< m; j++ ) {
cout<< ground[ i] [ j] ;
}
cout<< endl;
}
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 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
第九题 序列计数
题目
【问题描述】
小明想知道,满足以下条件的正整数序列的数量:
1. 第一项为 n;
2. 第二项不超过 n;
3. 从第三项开始,每一项小于前两项的差的绝对值。
请计算,对于给定的 n,有多少种满足条件的序列。
【输入格式】
输入一行包含一个整数 n。
【输出格式】
输出一个整数,表示答案。答案可能很大,请输出答案除以10000 的余数。
【样例输入】
4
【样例输出】
7
【样例说明】
以下是满足条件的序列:
4 1
4 1 1
4 1 2
4 2
4 2 1
4 3
4 4
【评测用例规模与约定】
对于 20 % 的评测用例,1 <= n <= 5 ;
对于 50 % 的评测用例,1 <= n <= 10 ;
对于 80 % 的评测用例,1 <= n <= 100 ;
对于所有评测用例,1 <= n <= 1000 。
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 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
思路1:记忆型递归 O(N^3)
首先确定递归式:
f(pre,cur) = f(cur,1) + f(cur,2) + … +f(cur,abs(pre-cur)-1) + 1
pre表示前一个数,cur代表当前的数,选定之后,序列种数等于以cur为前序,以1到abs-1为当前的序列数的总和再加1.如f(5,2) = f(2,1)+f(2,2).
但是暴力递归的复杂度是指数级; 基本的优化方案是加状态记忆:输入1000时,实测运行时间为1000~2000ms;
代码如下:
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <ctime>
typedef long long LL;
using namespace std;
int N;
LL ans;
const int MOD = 10000 ;
int mem[ 1001 ] [ 1000 ] ;
LL dfs ( int pre, int cur) {
if ( mem[ pre] [ cur] != 0 )
return mem[ pre] [ cur] ;
LL ans = 1 ;
for ( int j= 1 ; j<= abs ( pre- cur) - 1 ; j++ )
{
ans = ( ans + dfs ( cur, j) ) % MOD;
}
mem[ pre] [ cur] = ans;
return ans;
}
int main ( ) {
ans = 0 ;
cin >> N;
for ( int x= 1 ; x<= N; x++ )
ans = ( ans + dfs ( N, x) ) % MOD;
cout<< ans<< endl;
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 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
思路2:进一步优化 O(N^2)
重新考虑状态的转移:如果我们用F(i,j)表示前一个数pre是i,当前数cur是1到j的合法序列的个数;即:
F(i, j) = f(i, 1) + f(i, 2) + f(i, 3) +…+ f(i, j-1) + f(i, j) = F(i, j-1) + f(i, j)
由思路1可知:f(pre,cur) = f(cur,1) + f(cur,2) + … +f(cur,abs(pre-cur)-1) + 1 = F(cur, abs(pre-cur)-1) + 1
故思路2的迭代公式为:
F(i, j) = F(i, j-1) + F(i, abs(i-j)-1) + 1
代码如下:
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <ctime>
typedef long long LL;
using namespace std;
int N;
const int MOD = 10000 ;
int mem[ 1001 ] [ 1000 ] ;
int dfs ( int pre, int cur) {
if ( cur <= 0 ) return 0 ;
if ( mem[ pre] [ cur] != 0 ) return mem[ pre] [ cur] ;
return mem[ pre] [ cur] = ( 1 + dfs ( pre, cur - 1 ) + dfs ( cur, abs ( pre - cur) - 1 ) ) % MOD;
}
int main ( ) {
cin >> N;
cout << dfs ( N, N) << endl;
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 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 个节目。然后晚会的时间有限,他只能最终选择其中的 m 个节目。
这 n 个节目是按照小明设想的顺序给定的,顺序不能改变。
小明发现,观众对于晚会的喜欢程度与前几个节目的好看程度有非常大的关系,他希望选出的第一个节目尽可能好看,在此前提下希望第二个节目尽可能好看,依次类推。
小明给每个节目定义了一个好看值,请你帮助小明选择出 m 个节目,满足他的要求。
【输入格式】
输入的第一行包含两个整数 n, m ,表示节目的数量和要选择的数量。
第二行包含 n 个整数,依次为每个节目的好看值。
【输出格式】
输出一行包含 m 个整数,为选出的节目的好看值。
【样例输入】
5 3
3 1 2 5 4
【样例输出】
3 5 4
【样例说明】
选择了第1 , 4 , 5 个节目。
【评测用例规模与约定】
对于 30 % 的评测用例,1 <= n <= 20 ;
对于 60 % 的评测用例,1 <= n <= 100 ;
对于所有评测用例,1 <= n <= 100000 ,0 <= 节目的好看值 <= 100000 。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
代码
#include <iostream>
#include <vector>
using namespace std;
int main ( ) {
int N= 0 , M= 0 ;
cin >> N >> M;
vector< int > games ( N) ;
for ( int i = 0 ; i < N; i++ ) {
cin >> games[ i] ;
}
int pos_max = 0 , pos_1 = 0 , pos_2 = N - M;
while ( pos_1 < pos_2 && pos_2 < N) {
while ( pos_1 < pos_2) {
if ( games[ ++ pos_1] > games[ pos_max] ) pos_max = pos_1;
}
cout << games[ pos_max] << " " ;
pos_1 = pos_max + 1 ;
pos_2++ ;
pos_max = pos_1;
}
while ( pos_2 != N) {
cout << games[ pos_2++ ] << " " ;
}
cout << endl;
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 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