一、选择题
第一题（难度系数 2）
题目编号：LQQS22103001PX01 知识点考察：运算符
执行cout<<(5%3);语句后，输出的结果是（ ）。
*选择题严禁使用程序验证，选择题不答和答错不扣分
A、0 B、1 C、2 D、3
第二题（难度系数 2）
题目编号：LQQS22103001PX02 知识点：注释
以下选项中，哪一个是C++注释符号？（ ）。
*选择题严禁使用程序验证，选择题不答和答错不扣分
A、* B、// C、; D、#
第三题（难度系数 2）
题目编号：LQQS22103001PX03 知识点：参数
以下关于在C++中，对形式参数描述不正确的是（ ）。
*选择题严禁使用程序验证，选择题不答和答错不扣分
A、形式参数可以为空
B、形式参数必须有类型说明
C、多个形式参数之间以分号隔开
D、函数有无形式参数，函数名后的小括号都不能省略
第四题（难度系数 3）
题目编号：LQQS22103001PX04 知识点：数据类型 判断
可以正确判断char类型变量c是小写字母的是（ ）。
*选择题严禁使用程序验证，选择题不答和答错不扣分
A、 'a'<=c<='z' B、 ('a'>=c) && ('z'<=c) C、 (c>='a') && (c<='z') D、 ('a'>=c) || ('z'<=c)
第五题（难度系数 5）
题目编号：LQQS22103001PX05 知识点：指针
以下说法正确的是（ ）。
*选择题严禁使用程序验证，选择题不答和答错不扣分
A、可以通过&p来间接访问指针变量p所指向的数据内容
B、指针变量里面存放变量的地址，指针变量里面的值初始化之后不可改变
C、 定义为指向int型变量的指针，可以指向double类型的变量
D、 C++中，通过函数名称可以获取到函数的地址
编程题
第一题（难度系数2，15 个计分点）
题目编号：LQQS22103001PB01 知识点：运算符
编程实现：百位上的数字
题目描述：
给定一个三位数，输出其百位上的数字。
输入描述：输入一个三位数
输出描述：输出三位数百位上的数字
样例输入：123
样例输出：1
评分标准：
5分：能正确输出一组数据；
5分：能正确输出两组数据；
5分：能正确输出三组数据。
测试用例：
输入
555
987
132
输出
5
9
1
#include<iostream>
using namespace std;
int main(){
int n;
cin>>n;
cout<<n/100<<endl;
return 0;
}
第二题（难度系数 3，18 个计分点）
题目编号：LQQS22103001PB02 知识点：判断 运算符
编程实现：开关
题目描述：
一盏台灯的开关可以控制三种灯光状态。初始状态为关闭状态，第一次按下开关为冷光状态，第二次按下开关为暖光状态，第三次按下开关为关闭状态，第四次按下开关继续为冷光状态，以此类推。请计算出按下N次开关后，台灯为何种状态。
输入描述：输入一个正整数N（1<N<1000），表示按下台灯开关的次数（初始状态为关闭状态）
输出描述：输出一个大写字母，当按下台灯开关N次后，灯光为冷光状态则输出大写字母“L”，为暖光状态则输出大写字母“N”，为关闭状态则输出大写字母“G”
样例输入：5
样例输出：N
评分标准：
6分：能正确输出一组数据；
6分：能正确输出两组数据；
6分：能正确输出三组数据。
测试用例：
输入
3
11
997
输出
G
N
L
#include<iostream>
using namespace std;
int main() {
int n;
cin >> n;
if(n % 3 == 0)
cout << "G" << endl;
else if(n % 3 == 1)
cout << "L" << endl;
else
cout << "N" << endl;
return 0;
}
第三题（难度系数 3，25 个计分点）
题目编号：LQQS22103001PB03 知识点：判断 数学运算符 while循环
编程实现：对折纸张
题目描述：
现要对一张纸张进行反复对折，纸张的单页厚度为0.2毫米，请问最少对折几次后，纸的厚度超过N毫米（N为正整数，1<N<1000）。
输入描述：输入一个正整数N（1<N<1000）
输出描述：输出一个整数，表示纸张最少对折几次后，纸的厚度超过N毫米（大于N毫米）
样例输入：2
样例输出：4
评分标准：
5分：能正确输出一组数据；
5分：能正确输出两组数据；
5分：能正确输出三组数据；
5分：能正确输出四组数据。
测试用例：
输入
6
213
600
982
输出
5
11
12
13
#include<iostream>
using namespace std;
int main() {
int n, cnt = 0;
double sum = 0.2;
cin >> n;
while(sum < n) {
sum *= 2;
cnt++;
}
cout << cnt << endl;
return 0;
}
第四题（难度系数4，30个计分点）
题目编号：LQQS22103001PB04 知识点：循环 判断
编程实现：分糖果
题目描述：
现有N罐糖果，且已知每罐糖果的初始数量。现给出两个数值L和R（L≤R），需要把每罐糖果的数量调整为：L≤任意一罐糖果的数量≤R。调整的方式是每次从其中一罐糖果中拿出1块放到其他糖果罐中。请你计算出最少调整几次才能使每罐糖果的数量都在L到R范围之间，如果不能将每罐糖果都调整到L到R范围之间则输出-1。
例如：N = 2，2罐糖果的初始数量为3和8，L = 3，R = 6，通过调整使得：3≤任意一罐糖果的数量≤6，调整方式如下：
第一次从初始数量为8的罐中拿1块放到初始数量为3的罐中，调整后为（4，7）；
第二次从数量7的罐中拿1块放到数量为4的罐中，调整后为（5，6）；
故最少调整2次。
输入描述：
第一行输入一个正整数N（N<30），表示糖果的罐数
第二行输入N个正整数（1≤正整数≤100），表示每罐糖果的初始数量，每个正整数之间以一个空格隔开
第三行输入两个正整数L，R（1≤L≤R≤100），表示每罐糖果的数量所要调整的范围，两个正整数之间以一个空格隔开
输出描述：
输出一个整数，表示最少调整几次才可以使N罐糖果数量都在L和R范围之间，如果不能将N罐糖果调整到L到R范围之间则输出-1
样例输入：
2
3 8
3 6
样例输出：
2
评分标准：
6分：能正确输出一组数据；
6分：能正确输出两组数据；
6分：能正确输出三组数据；
7分：能正确输出四组数据。
测试用例：
输入
2
10 20
10 15
5
11 12 13 14 15
10 15
8
23 25 66 23 48 99 88 25
22 30
18
28 43 55 76 32 44 69 43 25 76 25 65 34 72 23 54 22 30
45 100
输出
5
0
-1
146
#include<iostream>
using namespace std;
int main() {
int my_arr[31];
int n, L, R, sum = 0;
int less = 0, more = 0;
cin >> n;
for(int i = 1; i <= n; i++) {
cin >> my_arr[i];
sum += my_arr[i];
}
cin >> L >> R;
if((double)sum / n < L || (double)sum / n > R) {
cout << "-1" << endl;
return 0;
}
for(int i = 1; i <= n; i++) {
if(my_arr[i] < L)less += (L - my_arr[i]);
if(my_arr[i] > R)more += (my_arr[i] - R);
}
cout << max(less, more) << endl;
return 0;
}第五题（难度系数 5，35 个计分点）
题目编号：LQQS22103001PB05 知识点：动态规划
编程实现：最长路线
题目描述：
有一个N*M的矩阵，且矩阵中每个方格中都有一个整数（0≤整数≤100） ，小蓝需要按照以下要求从矩阵中找出一条最长的移动路线，且输出最长路线的长度（1个方格为1个长度）。
要求：
1.小蓝可以从矩阵中任意一个方格开始向它的上、下、左、右相邻的任意一个方格移动，且移动的路线不能有交叉；
2.小蓝每次所要移动到的方格中的整数都要小于当前所在方格中的整数（如当前所在的方格中的整数为3，那么可以移动到数字为0，1，2的格子里，不可以移动到数字为3，4，5...的格子里）；
例如：N=3，M=3，矩阵方格如下：
最长路线为4 -> 3 -> 2 -> 1，故路线长度为4。
输入描述：
第一行输入两个正整数N，M（1＜N≤1000，1＜M≤1000），N表示矩阵的行数，M表示矩阵的列数，两个正整数之间以一个空格隔开
第二行开始输入N行，每行包含M个整数（0≤每个整数≤100），表示每个方格中的整数，每个整数之间以一个空格隔开
输出描述：
输出一个整数，表示最长路线的长度
样例输入：
3 3
1 1 3
2 3 4
1 1 1
样例输出：
4
评分标准：
6分：能正确输出一组数据；
6分：能正确输出两组数据；
6分：能正确输出三组数据；
6分：能正确输出四组数据；
6分：能正确输出五组数据。
测试用例：
输入
3 3
1 2 1
1 0 1
0 1 6
5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9
7 6
61 91 95 42 27 36
91 4 2 53 92 82
21 16 18 95 47 26
71 38 40 94 95 24
19 25 76 94 58 2
71 66 78 93 53 68
33 65 11 60 96 67
5 8
69 12 67 99 35 94 3 11
22 33 73 64 41 11 53 68
47 44 62 57 37 59 23 41
29 78 16 35 90 42 88 6
40 42 64 48 46 5 90 29
13 10
13 74 70 70 35 33 11 60 96 67
85 50 40 94 95 24 19 25 76 94
58 2 71 66 78 93 51 84 18 64
19 52 0 87 60 26 10 57 70 15
76 27 43 58 64 9 82 86 65 87
77 74 25 27 29 28 23 20 2 62
23 96 37 61 9 69 5 11 35 48
75 38 23 42 54 11 41 75 59 25
21 70 26 34 5 83 50 98 79 1
93 34 37 34 56 93 76 5 62 48
81 0 13 41 55 55 42 62 11 77
24 78 52 43 96 73 40 13 75 72
18 10 17 32 12 95 69 31 40 88
输出
3
25
9
5
8
#include<iostream>
using namespace std;
int my_arr[1001][1001];
bool flag[1001][1001];
int n, m;
int cnt = 1;
int max_cnt = 1;
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
void dfs(int x, int y) {
if((my_arr[x][y] <= my_arr[x - 1][y] || x - 1 < 1) && (my_arr[x][y] <= my_arr[x + 1][y] || x + 1 > m) && (my_arr[x][y] <= my_arr[x][y - 1] || y - 1 < 1) && (my_arr[x][y] <= my_arr[x][y + 1] || y + 1 > n)) {
if(cnt > max_cnt)max_cnt = cnt;
return;
}
for(int i = 0; i < 4; i++) {
int tx = x + dx[i];
int ty = y + dy[i];
if(tx >= 1 && tx <= m && ty >= 1 && ty <= n && flag[tx][ty] == 0 && my_arr[tx][ty] < my_arr[x][y]) {
flag[tx][ty] = 1;
cnt++;
dfs(tx, ty);
flag[tx][ty] = 0;
cnt--;
}
}
}
int main() {
cin >> n >> m;
int result = 1;
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= m; j++) {
cin >> my_arr[i][j];
}
}
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= m; j++) {
max_cnt = 1;
cnt = 1;
for(int x = 1; x <= n; x++) {
for(int y = 1; y <= m; y++) {
flag[x][y] = 0;
}
}
flag[i][j] = 1;
dfs(i, j);
if(max_cnt > result)result = max_cnt;
}
}
cout << result << endl;
return 0;
}
1886
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
