电子学会等级考级c语言真题下载

最新推荐文章于 2024-09-13 19:00:00 发布

kodu

最新推荐文章于 2024-09-13 19:00:00 发布

阅读量326

点赞数 3

文章标签：青少年编程

本文链接：https://blog.csdn.net/liuhejianwei/article/details/140909822

版权

202006软件编程（C语言）真题——（1级）

202006软件编程（C语言）真题——（2级）

202006软件编程（C语言）真题——（3级）

202006软件编程（C语言）真题——（4级）

202109软件编程（C语言）真题——（1-6级）

202212软件编程（C语言）真题——（1级）

202212软件编程（C语言）真题——（2级）

202212软件编程（C语言）真题——（3级）

202212软件编程（C语言）真题——（4级）

202212软件编程（C语言）真题——（5级）

202212软件编程（C语言）真题——（6级）

202212软件编程（C语言）真题——（7级）

202212软件编程（C语言）真题——（8级）

青少年软件编程（C语言）等级考试试卷（一级）

分数：100 题数：5

总体情况
姓名	开始时间	结束时间	用时(分钟)	得分	得分率	是否通过	考试状态

一、编程题(共5题，共100分)

1.	鸡尾酒疗法


	试题编号：20200621-105
	试题类型：编程题
	标准答案：
	试题难度：一般
	试题解析：
	考生答案：（此题已作答）
	考生得分：20
	是否评分：已评分
	评价描述：

2.	判断是否存在重复的数


	试题编号：20200621-103
	试题类型：编程题
	标准答案：
	试题难度：一般
	试题解析：
	考生答案：（此题已作答）
	考生得分：20
	是否评分：已评分
	评价描述：

3.	日期输出


	试题编号：20200621-101
	试题类型：编程题
	标准答案：
	试题难度：一般
	试题解析：
	考生答案：（此题已作答）
	考生得分：20
	是否评分：已评分
	评价描述：

4.	计算表达式的值


	试题编号：20200621-102
	试题类型：编程题
	标准答案：
	试题难度：一般
	试题解析：
	考生答案：（此题已作答）
	考生得分：20
	是否评分：已评分
	评价描述：

5.	与指定数字相同的数的个数


	试题编号：20200621-104
	试题类型：编程题
	标准答案：
	试题难度：一般
	试题解析：
	考生答案：（此题已作答）
	考生得分：20
	是否评分：已评分
	评价描述：

鸡尾酒疗法

鸡尾酒疗法，原指“高效抗逆转录病毒治疗”（HAART），由美籍华裔科学家何大一于1996年提出，是通过三种或三种以上的抗病毒药物联合使用来治疗艾滋病。该疗法的应用可以减少单一用药产生的抗药性，最大限度地抑制病毒的复制，使被破坏的机体免疫功能部分甚至全部恢复，从而延缓病程进展，延长患者生命，提高生活质量。人们在鸡尾酒疗法的基础上又提出了很多种改进的疗法。为了验证这些治疗方法是否在疗效上比鸡尾酒疗法更好，可用通过临床对照实验的方式进行。假设鸡尾酒疗法的有效率为x，新疗法的有效率为y，如果y-x大于5%，则效果更好，如果x-y大于5%，则效果更差，否则称为效果差不多。下面给出n组临床对照实验，其中第一组采用鸡尾酒疗法，其他n-1组为各种不同的改进疗法。请写程序判定各种改进疗法效果如何。

时间限制：10000

内存限制：65536

输入

第一行为整数n（ 1 < n <= 20）；其余n行每行两个整数，第一个整数是临床实验的总病例数(小于等于10000)，第二个疗效有效的病例数。这n行数据中，第一行为鸡尾酒疗法的数据，其余各行为各种改进疗法的数据。

输出

有n-1行输出，分别表示对应改进疗法的效果：如果效果更好，输出better；如果效果更差，输出worse；否则输出same

样例输入

125 99

112 89

145 99

99 97

123 98

样例输出

same

worse

better

same

代码预览:

判断是否存在重复的数

给定3个数，判断是否存在2个数相等，如果存在输出"YES", 否者输出"NO"。

时间限制：5000

内存限制：65536

输入

1行，包含3个整数，以空格分隔。

输出

按照题目要求输出结果

样例输入

2 7 2

样例输出

YES

日期输出

给定两个整数，表示一个日期的月和日。请按照"MM-DD"的格式输出日期，即如果月和日不到2位时，填补0使得满足2位。

时间限制：10000

内存限制：65536

输入

2个整数m,d（0 < m <= 12, 0 < d <= 31）。数据保证日期合法。

输出

按照题目要求输出日期

样例输入

7 18

样例输出

07-18

计算表达式的值

给定整数x,y的值，计算3*x+2*y的值。

时间限制：3000

内存限制：65536

输入

一行包含2个整数x,y，以空格作为分隔。数据保证最后计算结果还在整数表示范围内。

输出

按照题目要求输出结果

样例输入

2 3

样例输出

与指定数字相同的数的个数

输出一个整数序列中与指定数字相同的数的个数。

时间限制：10000

内存限制：65536

输入

输入包含2行：第1行为N和m，表示整数序列的长度(N <= 100)和指定的数字，中间用一个空格分开；第2行为N个整数，整数之间以一个空格分开。

输出

输出为N个数中与m相同的数的个数。

样例输入

3 2

2 3 2

样例输出

2青少年软件编程（C语言）等级考试试卷（二级）

分数：100 题数：5

总体情况

一、编程题(共5题，共100分)

1.	计算矩阵边缘元素之和


	试题编号：20200621-203
	试题类型：编程题
	标准答案：
	试题难度：一般
	试题解析：
	考生答案：（此题已作答）
	考生得分：20
	是否评分：已评分
	评价描述：

2.	最长最短单词


	试题编号：20200621-202
	试题类型：编程题
	标准答案：
	试题难度：一般
	试题解析：
	考生答案：（此题已作答）
	考生得分：0
	是否评分：已评分
	评价描述：

3.	啤酒厂选址


	试题编号：20200621-205
	试题类型：编程题
	标准答案：
	试题难度：一般
	试题解析：
	考生答案：（此题已作答）
	考生得分：20
	是否评分：已评分
	评价描述：

4.	统计误差范围内的数


	试题编号：20200621-201
	试题类型：编程题
	标准答案：
	试题难度：一般
	试题解析：
	考生答案：（此题已作答）
	考生得分：20
	是否评分：已评分
	评价描述：

5.	单词排序


	试题编号：20200621-204
	试题类型：编程题
	标准答案：
	试题难度：一般
	试题解析：
	考生答案：（此题已作答）
	考生得分：20
	是否评分：已评分
	评价描述：

计算矩阵边缘元素之和

输入一个整数矩阵，计算位于矩阵边缘的元素之和。所谓矩阵边缘的元素，就是第一行和最后一行的元素以及第一列和最后一列的元素。

时间限制：10000

内存限制：65536

输入

第一行分别为矩阵的行数m和列数n（m < 100，n < 100），两者之间以一个空格分开。接下来输入的m行数据中，每行包含n个整数，整数之间以一个空格分开。

输出

输出对应矩阵的边缘元素和

样例输入

3 3

3 4 1

3 7 1

2 0 1

样例输出

最长最短单词

输入1行句子（不多于200个单词，每个单词长度不超过100），只包含字母、空格和逗号。单词由至少一个连续的字母构成，空格和逗号都是单词间的间隔。

试输出第1个最长的单词和第1个最短单词。

时间限制：10000

内存限制：65536

输入

一行句子。

输出

两行输出：第1行，第一个最长的单词。第2行，第一个最短的单词。

样例输入

I am studying Programming language C in Peking University

样例输出

Programming

提示

如果所有单词长度相同，那么第一个单词既是最长单词也是最短单词。

啤酒厂选址

海上有一个岛，在环海边上建有一条环岛高速公路，沿着公路有n（5 < n < 10000）个居民点，假设每个居民点有一个编号，从0开始，按顺时针依次从小到大（即，0,1，…，n-1）编号。在岛上啤酒很受青睐。某啤酒企业计划在岛上投资建一个啤酒厂，并根据啤酒需求每天向居住点送啤酒。已知两个相邻的居民点的距离以及每个居住点每天的啤酒需求量（假设每个居住点每天不超过2000桶）。假定每单位长度的路程送一桶啤酒需要的费用恒定（为单位费用）。请问，选择哪一个居民点建啤酒厂，才能使每天送啤酒的费用最小（空车不计费用）。

时间限制：10000

内存限制：65536

输入

第一行：为居民点数目n 后面为n行，每行为一个居民点的啤酒需求量以及按顺时针离下一个居民点的距离（均为整数,空格间隔），从编号为0的开始，按单增顺次给出。注意：后面第n行对应于居民点（n-1)的啤酒需求量以及到编号为0的居民点距离。

输出

啤酒厂所在的居民点编号以及每天的运输费用，其间以逗号间隔

样例输入

500 10

300 30

350 25

400 60

700 28

200 35

样例输出

0,94100

代码预览:

单词排序

输入一行单词序列，相邻单词之间由1个或多个空格间隔，请按照字典序输出这些单词，要求重复的单词只输出一次。（区分大小写）

时间限制：10000

内存限制：65536

输入

一行单词序列，最少1个单词，最多100个单词，每个单词长度不超过50，单词之间用至少1个空格间隔。数据不含除字母、空格外的其他字符。

输出

按字典序输出这些单词，重复的单词只输出一次。

样例输入

She wants to go to Peking University to study Chinese

样例输出

Chinese

Peking

She

University

study

wants青少年软件编程（C语言）等级考试试卷（三级）

分数：100 题数：5

一、编程题(共5题，共100分)

1.	最接近的分数


	试题编号：20200621-302
	试题类型：编程题
	标准答案：
	试题难度：一般

2.	和数


	试题编号：20200621-301
	试题类型：编程题
	标准答案：
	试题难度：一般

3.	吃糖果


	试题编号：20200621-303
	试题类型：编程题
	标准答案：
	试题难度：一般

4.	汉诺塔问题


	试题编号：20200621-305
	试题类型：编程题
	标准答案：
	试题难度：一般

5.	文件结构“图”


	试题编号：20200621-304
	试题类型：编程题
	标准答案：
	试题难度：一般

最接近的分数

分母不超过 N 且小于 A/B 的最大最简分数是多少？

时间限制：10000

内存限制：65536

输入

三个正整数N，A，B，相邻两个数之间用单个空格隔开。1 <= A < B < N <= 1000。

输出

两个正整数，分别是所求分数的分子和分母，中间用单个空格隔开。

样例输入

100 7 13

样例输出

50 93

和数

给定一个正整数序列，判断其中有多少个数，等于数列中其他两个数的和。比如，对于数列1 2 3 4, 这个问题的答案就是2, 因为3 = 2 + 1, 4 = 1 + 3。

时间限制：10000

内存限制：65536

输入

共两行，第一行是数列中数的个数n ( 1 <= n <= 100)，第二行是由n个不大于10000的正整数组成的数列，相邻两个整数之间用单个空格隔开。

输出

一个整数，即数列中等于其他两个数之和的数的个数。

样例输入

1 2 3 4

样例输出

吃糖果

现有n(20 > n > 0)个糖果,每天可以吃1个,也可以每天吃2个,也可以每天吃3个，请计算共有多少种不同的吃法。

时间限制：1000

内存限制：65536

输入

输入的每一行包括一组测试数据，即为糖果数n。最后一行为0，表示测试结束。

输出

每一行输出对应一行输入的结果，即为吃法的数目。

样例输入

样例输出

汉诺塔问题

约19世纪末，在欧州的商店中出售一种智力玩具，在一块铜板上有三根杆，最左边的杆上自上而下、由小到大顺序串着由64个圆盘构成的塔。目的是将最左边杆上的盘全部移到中间的杆上，条件是一次只能移动一个盘，且不允许大盘放在小盘的上面。这是一个著名的问题，几乎所有的教材上都有这个问题。由于条件是一次只能移动一个盘，且不允许大盘放在小盘上面，所以64个盘的移动次数是：18,446,744,073,709,551,615 这是一个天文数字，若每一微秒可能计算(并不输出)一次移动，那么也需要几乎一百万年。我们仅能找出问题的解决方法并解决较小N值时的汉诺塔，但很难用计算机解决64层的汉诺塔。假定圆盘从小到大编号为1, 2, ...

时间限制：11000

内存限制：65536

输入

输入为一个整数后面跟三个单字符字符串。整数为盘子的数目，后三个字符表示三个杆子的编号。

输出

输出每一步移动盘子的记录。一次移动一行。每次移动的记录为例如 a->3->b 的形式，即把编号为3的盘子从a杆移至b杆。

样例输入

2 a b c

样例输出

a->1->c

a->2->b

c->1->b

文件结构“图”

在计算机上看到文件系统的结构通常很有用。Microsoft Windows上面的"explorer"程序就是这样的一个例子。但是在有图形界面之前，没有图形化的表示方法的，那时候最好的方式是把目录和文件的结构显示成一个"图"的样子，而且使用缩排的形式来表示目录的结构。比如：

ROOT

| dir1

| file1

| file2

| file3

| dir2

| dir3

| file1

file1

file2

这个图说明：ROOT目录包括三个子目录和两个文件。第一个子目录包含3个文件，第二个子目录是空的，第三个子目录包含一个文件。

时间限制：1000

内存限制：65536

输入

你的任务是写一个程序读取一些测试数据。每组测试数据表示一个计算机的文件结构。每组测试数据以'*'结尾，而所有合理的输入数据以'#'结尾。一组测试数据包括一些文件和目录的名字（虽然在输入中我们没有给出，但是我们总假设ROOT目录是最外层的目录）。在输入中,以']'表示一个目录的内容的结束。目录名字的第一个字母是'd'，文件名字的第一个字母是'f'。文件名可能有扩展名也可能没有（比如fmyfile.dat和fmyfile）。文件和目录的名字中都不包括空格,长度都不超过30。一个目录下的子目录个数和文件个数之和不超过30。

输出

在显示一个目录中内容的时候，先显示其中的子目录（如果有的话），然后再显示文件（如果有的话）。文件要求按照名字的字母表的顺序显示（目录不用按照名字的字母表顺序显示，只需要按照目录出现的先后显示）。对每一组测试数据，我们要先输出"DATA SET x:"，这里x是测试数据的编号（从1开始）。在两组测试数据之间要输出一个空行来隔开。你需要注意的是，我们使用一个'|'和5个空格来表示出缩排的层次。

样例输入

file1

file2

dir3

dir2

file1

file2

]

file4

dir1

]

file3

file2

file1

样例输出

DATA SET 1:

ROOT

| dir3

| | dir2

| | file1

| | file2

| dir1

file1

file2

file3

file4

DATA SET 2:

ROOT

file1

file2

提示

一个目录和它的子目录处于不同的层次一个目录和它的里面的文件处于同一层次

代码预览:青少年软件编程（C语言）等级考试试卷（四级）

分数：100 题数：4

一、编程题(共4题，共100分)

1.	最长上升子序列


	试题编号：20200621-401
	试题类型：编程题
	标准答案：
	试题难度：一般

2.	核电站


	试题编号：20200621-403
	试题类型：编程题
	标准答案：
	试题难度：一般

3.	山区建小学


	试题编号：20200621-404
	试题类型：编程题
	标准答案：
	试题难度：一般

4.	公共子序列


	试题编号：20200621-402
	试题类型：编程题
	标准答案：
	试题难度：一般
	试题解析：

最长上升子序列

一个数的序列bi，当b1 < b2 < ... < bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, ..., aN)，我们可以得到一些上升的子序列(ai1, ai2, ..., aiK)，这里1 <= i1 < i2 < ... < iK <= N。比如，对于序列(1, 7, 3, 5, 9, 4, 8)，有它的一些上升子序列，如(1, 7), (3, 4, 8)等等。这些子序列中最长的长度是4，比如子序列(1, 3, 5, 8). 你的任务，就是对于给定的序列，求出最长上升子序列的长度。

时间限制：11000

内存限制：65536

输入

输入的第一行是序列的长度N (1 <= N <= 1000)。第二行给出序列中的N个整数，这些整数的取值范围都在0到10000。

输出

最长上升子序列的长度。

样例输入

1 7 3 5 9 4 8

样例输出

核电站

一个核电站有N个放核物质的坑，坑排列在一条直线上。如果连续M个坑中放入核物质，则会发生爆炸，于是，在某些坑中可能不放核物质。

任务：对于给定的N和M，求不发生爆炸的放置核物质的方案总数

时间限制：6000

内存限制：131072

输入

只一行，两个正整数N，M( 1 < N < 50，2 ≤ M ≤ 5 )

输出

一个正整数S，表示方案总数。

样例输入

4 3

样例输出

山区建小学

政府在某山区修建了一条道路，恰好穿越总共m个村庄的每个村庄一次，没有回路或交叉，任意两个村庄只能通过这条路来往。已知任意两个相邻的村庄之间的距离为di（为正整数），其中，0 < i < m。为了提高山区的文化素质，政府又决定从m个村中选择n个村建小学（设 0 < n < = m < 500 ）。请根据给定的m、n以及所有相邻村庄的距离，选择在哪些村庄建小学，才使得所有村到最近小学的距离总和最小，计算最小值。

时间限制：24000

内存限制：65536

输入

第1行为m和n，其间用空格间隔第2行为(m-1) 个整数，依次表示从一端到另一端的相邻村庄的距离，整数之间以空格间隔。例如 10 3 2 4 6 5 2 4 3 1 3 表示在10个村庄建3所学校。第1个村庄与第2个村庄距离为2，第2个村庄与第3个村庄距离为4，第3个村庄与第4个村庄距离为6，...，第9个村庄到第10个村庄的距离为3。

输出

各村庄到最近学校的距离之和的最小值。

样例输入

10 2

3 1 3 1 1 1 1 1 3

样例输出

公共子序列

我们称序列Z = < z1, z2, ..., zk >是序列X = < x1, x2, ..., xm >的子序列当且仅当存在严格上升的序列< i1, i2, ..., ik >，使得对j = 1, 2, ... ,k, 有xij = zj。比如Z = < a, b, f, c > 是X = < a, b, c, f, b, c >的子序列。现在给出两个序列X和Y，你的任务是找到X和Y的最大公共子序列，也就是说要找到一个最长的序列Z，使得Z既是X的子序列也是Y的子序列。

时间限制：3000

内存限制：65536

输入

输入包括多组测试数据。每组数据包括一行，给出两个长度不超过200的字符串，表示两个序列。两个字符串之间由若干个空格隔开。

输出

对每组输入数据，输出一行，给出两个序列的最大公共子序列的长度。

样例输入

abcfbc abfcab

programming contest

abcd mnp

样例输出

0青少年软件编程（C语言）等级考试试卷（一级）

加一

输入一个整数x，输出这个整数加1后的值，即x+1的值。

时间限制：1000

内存限制：65536

输入

一个整数x（0 ≤ x ≤ 1000）。

输出

按题目要求输出一个整数。

样例输入

样例输出

(a/b)*c的值

给定整数a、b、c，计算(a / b)*c的值，这里的除法为实数除法。

时间限制：1000

内存限制：65536

输入

一行，三个整数a、b、c，整数间以空格分隔。（1 ≤ a,b,c ≤ 1000）

输出

将计算结果保留6位小数输出。

样例输入

1 3 3

样例输出

1.000000

判断是否存在重复的数

给定3个数，判断是否存在2个数相等，如果存在输出"YES", 否者输出"NO"。

时间限制：5000

内存限制：65536

输入

1行，包含3个整数，以空格分隔。

输出

按照题目要求输出结果

样例输入

2 7 2

样例输出

YES

整数的立方和

给定一个正整数k（1<k<10），求1到k的立方和m。即m=1+2*2*2+…+k*k*k。

时间限制：1000

内存限制：65536

输入

输入只有一行，该行包含一个正整数k。

输出

输出只有一行，该行包含1到k的立方和。

样例输入

样例输出

225

自整除数

对一个整数n,如果其各个位数的数字相加得到的数m能整除n,则称n为自整除数.例如21,21%(2+1)==0,所以21是自整除数.现求出从10到n(n < 100)之间的所有自整除数.

时间限制：1000

内存限制：65536

输入

有一行,整数n,(10 <= n < 100)

输出

有多行.按从小到大的顺序输出所有大于等于10,小于等于n的自整除数,每行一个自整除数.

样例输入

样例输出

45青少年软件编程（C语言）等级考试试卷（二级）

数组逆序重放

将一个数组中的值按逆序重新存放。例如，原来的顺序为8,6,5,4,1。要求改为1,4,5,6,8。

时间限制：1000

内存限制：65536

输入

输入为两行：第一行数组中元素的个数n（1<n<100)，第二行是n个整数，每两个整数之间用空格分隔。

输出

输出为一行：输出逆序后数组的整数，每两个整数之间用空格分隔。

样例输入

8 6 5 4 1

样例输出

1 4 5 6 8

最长最短单词

试输出第1个最长的单词和第1个最短单词。

时间限制：10000

内存限制：65536

输入

一行句子。

输出

两行输出：第1行，第一个最长的单词。第2行，第一个最短的单词。

样例输入

I am studying Programming language C in Peking University

样例输出

Programming

提示

如果所有单词长度相同，那么第一个单词既是最长单词也是最短单词。

计算鞍点

给定一个5*5的矩阵，每行只有一个最大值，每列只有一个最小值，寻找这个矩阵的鞍点。鞍点指的是矩阵中的一个元素，它是所在行的最大值，并且是所在列的最小值。例如：在下面的例子中（第4行第1列的元素就是鞍点，值为8 ）。

11 3 5 6 9

12 4 7 8 10

10 5 6 9 11

8 6 4 7 2

15 10 11 20 25

时间限制：1000

内存限制：65536

输入

输入包含一个5行5列的矩阵

输出

如果存在鞍点，输出鞍点所在的行、列及其值，如果不存在，输出"not found"

样例输入

11 3 5 6 9

12 4 7 8 10

10 5 6 9 11

8 6 4 7 2

15 10 11 20 25

样例输出

4 1 8

病人排队

病人登记看病，编写一个程序，将登记的病人按照以下原则排出看病的先后顺序： 1. 老年人（年龄 >= 60岁）比非老年人优先看病。 2. 老年人按年龄从大到小的顺序看病，年龄相同的按登记的先后顺序排序。 3. 非老年人按登记的先后顺序看病。

时间限制：1000

内存限制：65536

输入

第1行，输入一个小于100的正整数，表示病人的个数；后面按照病人登记的先后顺序，每行输入一个病人的信息，包括：一个长度小于10的字符串表示病人的ID（每个病人的ID各不相同且只含数字和字母），一个整数表示病人的年龄，中间用单个空格隔开。

输出

按排好的看病顺序输出病人的ID，每行一个。

样例输入

021075 40

004003 15

010158 67

021033 75

102012 30

样例输出

021033

010158

021075

004003

102012

循环数

若一个n位的数字串满足下述条件，则称其是循环数（cyclic）：将这个数字串视为整数（可能带有前导0），并用任意一个 1 到 n 之间（包含1和n）的整数去乘它时, 会得到一个将原数字串首尾相接后，再在某处断开而得到的新数字串所对应的整数。例如，数字 142857 是循环数，因为: 142857 *1 = 142857 142857 *2 = 285714 142857 *3 = 428571 142857 *4 = 571428 142857 *5 = 714285 142857 *6 = 857142。

请写一个程序判断给定的数是否是循环数。

注意：在此题中，输入数字串允许带前导0，且前导0不能被忽略，例如“01”是两位数字串，而“1”是一位数字串。但将数字串转化为整数做乘法运算或比较运算时，可以忽略前导0。

时间限制：10000

内存限制：65536

输入

一行，一个长度在 2 到 60 位之间的数字串。

输出

一个整数，若输入的数字串是循环数，输出1，否则输出0。

样例输入

142857

样例输出

1青少年软件编程（C语言）等级考试试卷（三级）

鸡兔同笼

一个笼子里面关了鸡和兔子（鸡有2只脚，兔子有4只脚，没有例外）。已经知道了笼子里面脚的总数a，问笼子里面至少有多少只动物，至多有多少只动物。

时间限制：1000

内存限制：65536

输入

一行，一个正整数a (a < 32768)。

输出

一行，包含两个正整数，第一个是最少的动物数，第二个是最多的动物数，两个正整数用一个空格分开。如果没有满足要求的答案，则输出两个0，中间用一个空格分开。

样例输入

样例输出

5 10

猴子吃桃

海滩上有一堆桃子，N只猴子来分。第一只猴子把这堆桃子平均分为N份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子接着把剩下的桃子平均分成N份，又多了一个，它同样把多的一个扔入海中，拿走了一份。第三、第四、……，第N只猴子仍是最终剩下的桃子分成N份，扔掉多了的一个，并拿走一份。编写程序，输入猴子的数量N，输出海滩上最少的桃子数，使得每只猴子都可吃到桃子。

时间限制：3000

内存限制：65536

输入

一个整数N。

输出

输出当猴子数量为N时海滩上最少的桃子数。结果保证在int型范围内。

样例输入

样例输出

扩号匹配问题

在某个字符串（长度不超过100）中有左括号、右括号和大小写字母；规定（与常见的算数式子一样）任何一个左括号都从内到外与在它右边且距离最近的右括号匹配。写一个程序，找到无法匹配的左括号和右括号，输出原来字符串，并在下一行标出不能匹配的括号。不能匹配的左括号用"$"标注,不能匹配的右括号用"?"标注.

时间限制：3000

内存限制：65536

输入

输入包括多组数据，每组数据一行，包含一个字符串，只包含左右括号和大小写字母，字符串长度不超过100

输出

对每组输出数据，输出两行，第一行包含原始输入字符，第二行由"$","?"和空格组成，"$"和"?"表示与之对应的左括号和右括号不能匹配。

样例输入

((ABCD(x)

)(rttyy())sss)(

样例输出

((ABCD(x)

)(rttyy())sss)(

? ?$

上台阶

楼梯有n(100 > n > 0)阶台阶,上楼时可以一步上1阶,也可以一步上2阶,也可以一步上3阶，编程计算共有多少种不同的走法。

时间限制：1000

内存限制：65536

输入

输入的每一行包括一组测试数据，即为台阶数n。最后一行为0，表示测试结束。

输出

每一行输出对应一行输入的结果，即为走法的数目。

样例输入

样例输出

田忌赛马

在田忌赛马的故事中，孙膑用自己的下等马对战对手的上等马，自己上等马对阵对手的中等马，自己的中等马对阵对手的下等马，从而赢得了胜利。现在即将进行的是N匹马的赛马比赛。双方队伍的马各分为N等。已知只有当我方马的等级比对方马等级高X等以上（包含X）时，我方才可以取得这场比赛的胜利。如果在N场比赛中我方的胜场数大于对方，则我方取得最终的胜利。现在已知对方这N场比赛的出战方案，请计算所有令我方最终获胜的出战方案。

时间限制：1000

内存限制：65536

输入

第一行两个整数，N和X。N≤9, 0 ≤ X < N。第二行N个正整数，A(1)....A(N)。A(i)表示第i场比赛对方马的等级，1≤i≤N。等级越高越强

输出

按字典序输出所有我方最终获胜的方案，每个方案一行。每行是N个正整数，第i个数表示我方第i场比赛马的等级。

样例输入

样例1输入

3 1

3 2 1

样例2输入

3 0

3 1 2

样例输出

样例1输出

1 3 2

样例2输出

1 2 3

1 3 2

2 1 3

3 1 2

3 2 1青少年软件编程（C语言）等级考试试卷（四级）

开餐馆

北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。小明打算从中选择合适的位置开设一些餐馆。这 n 个地点排列在同一条直线上。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。我们用pi 表示在mi 处开餐馆的利润。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。请你帮助小明选择一个总利润最大的方案。

时间限制：1000

内存限制：65536

输入

标准的输入包含若干组测试数据。输入第一行是整数T (1 <= T <= 1000) ，表明有T组测试数据。紧接着有T组连续的测试。每组测试数据有3行, 第1行:地点总数 n (n < 100), 距离限制 k (k > 0 && k < 1000). 第2行:n 个地点的位置m1 , m2, ... mn ( 1000000 > mi > 0 且为整数,升序排列) 第3行:n 个地点的餐馆利润p1 , p2, ... pn ( 1000 > pi > 0 且为整数)

输出

对于每组测试数据可能的最大利润

样例输入

3 11

1 2 15

10 2 30

3 16

1 2 15

10 2 30

样例输出

糖果

由于在维护世界和平的事务中做出巨大贡献，Dzx被赠予糖果公司2010年5月23日当天无限量糖果免费优惠券。在这一天，Dzx可以从糖果公司的N件产品中任意选择若干件带回家享用。糖果公司的N件产品每件都包含数量不同的糖果。Dzx希望他选择的产品包含的糖果总数是K的整数倍，这样他才能平均地将糖果分给帮助他维护世界和平的伙伴们。当然，在满足这一条件的基础上，糖果总数越多越好。Dzx最多能带走多少糖果呢？注意：Dzx只能将糖果公司的产品整件带走。

时间限制：7000

内存限制：65536

输入

第一行包含两个整数N(1<=N<=100)和K(1<=K<=100) 以下N行每行1个整数，表示糖果公司该件产品中包含的糖果数目，不超过1000000

输出

符合要求的最多能达到的糖果总数，如果不能达到K的倍数这一要求，输出0

样例输入

5 7

样例输出

提示

Dzx的选择是2+3+4+5=14，这样糖果总数是7的倍数，并且是总数最多的选择。

鸡蛋的硬度

最近XX公司举办了一个奇怪的比赛：鸡蛋硬度之王争霸赛。参赛者是来自世界各地的母鸡，比赛的内容是看谁下的蛋最硬，更奇怪的是XX公司并不使用什么精密仪器来测量蛋的硬度，他们采用了一种最老土的办法--从高度扔鸡蛋--来测试鸡蛋的硬度，如果一次母鸡下的蛋从高楼的第a层摔下来没摔破，但是从a+1层摔下来时摔破了，那么就说这只母鸡的鸡蛋的硬度是a。你当然可以找出各种理由说明这种方法不科学，比如同一只母鸡下的蛋硬度可能不一样等等，但是这不影响XX公司的争霸赛，因为他们只是为了吸引大家的眼球，一个个鸡蛋从100 层的高楼上掉下来的时候，这情景还是能吸引很多人驻足观看的，当然，XX公司也绝不会忘记在高楼上挂一条幅，写上“XX公司”的字样--这比赛不过是XX 公司的一个另类广告而已。勤于思考的小A总是能从一件事情中发现一个数学问题，这件事也不例外。“假如有很多同样硬度的鸡蛋，那么我可以用二分的办法用最少的次数测出鸡蛋的硬度”，小A对自己的这个结论感到很满意，不过很快麻烦来了，“但是，假如我的鸡蛋不够用呢，比如我只有1个鸡蛋，那么我就不得不从第1层楼开始一层一层的扔，最坏情况下我要扔100次。如果有2个鸡蛋，那么就从2层楼开始的地方扔……等等，不对，好像应该从1/3的地方开始扔才对，嗯，好像也不一定啊……3个鸡蛋怎么办，4个，5个，更多呢……”，和往常一样，小A又陷入了一个思维僵局，与其说他是勤于思考，不如说他是喜欢自找麻烦。好吧，既然麻烦来了，就得有人去解决，小A的麻烦就靠你来解决了：）

时间限制：1000

内存限制：65536

输入

输入包括多组数据，每组数据一行，包含两个正整数n和m(1<=n<=100,1<=m<=10)，其中n表示楼的高度，m表示你现在拥有的鸡蛋个数，这些鸡蛋硬度相同（即它们从同样高的地方掉下来要么都摔碎要么都不碎），并且小于等于n。你可以假定硬度为x的鸡蛋从高度小于等于x的地方摔无论如何都不会碎（没摔碎的鸡蛋可以继续使用），而只要从比x高的地方扔必然会碎。对每组输入数据，你可以假定鸡蛋的硬度在0至n之间，即在n+1层扔鸡蛋一定会碎。

输出

对于每一组输入，输出一个整数，表示使用最优策略在最坏情况下所需要的扔鸡蛋次数。

样例输入

100 1

100 2

样例输出

100

提示

最优策略指在最坏情况下所需要的扔鸡蛋次数最少的策略。如果只有一个鸡蛋，你只能从第一层开始扔，在最坏的情况下，鸡蛋的硬度是100，所以需要扔100次。如果采用其他策略，你可能无法测出鸡蛋的硬度(比如你第一次在第二层的地方扔,结果碎了,这时你不能确定硬度是0还是1)，即在最坏情况下你需要扔无限次，所以第一组数据的答案是100。

山区建小学

时间限制：24000

内存限制：65536

输入

输出

各村庄到最近学校的距离之和的最小值。

样例输入

10 2

3 1 3 1 1 1 1 1 3

样例输出

18青少年软件编程（C语言）等级考试试卷（五级）

漫漫回国路

2020年5月，国际航班机票难求。一位在美国华盛顿的中国留学生，因为一些原因必须在本周内回到北京。现在已知各个机场之间的航班情况，求问他回不回得来（不考虑转机次数和机票价格）。

时间限制：1000

内存限制：65536

输入

第一行为case个数n(n < 10)。每一个case，第一行为机场个数N，N ≤ 10。之后的N行，每一行包含N个整数。第i（1 ≤ i ≤ N）行的第j（1 ≤ j ≤ N）个整数代表从第i个机场出发到第j个机场的能买到的航班的最低票价t（0 < t < 10000）。如果不幸没有航班，那么用-1表示。第i行第i个整数为0。起点华盛顿杜勒斯国际机场的编号为1，终点北京首都国际机场的编号为N。

输出

每一个case一行。能够回国，输出字符串：YES。如果无法回国，输出字符串：NO

样例输入

0 100 -1

-1 0 200

-1 -1 0

0 1 5 -1

3 0 1 -1

2 4 0 -1

4 1 1 0

样例输出

YES

通配符匹配

给定一个字符串s和一个字符模式p，请实现一个支持'?'和'*'的通配符匹配功能。

其中‘?’可以匹配任何单个字符，如‘a?c’可以成功匹配‘aac’,‘abc’等字符串，但不可匹配‘ac’,‘aaac’等字符串。

‘*’ 可以匹配任意长度字符串（包括空字符串）,如‘a*c’可以成功匹配‘ac’,‘abdc’,‘abc’,‘aaac’等字符串，但不可匹配‘acb’，‘cac’等字符串。

两个字符串完全匹配才算匹配成功。

时间限制：2000

内存限制：262144

输入

输入为一个数字n表示测试字符串与字符模式对数，换行。(n ≤ 30) 后续2n行为每组匹配的s与p，每行字符串后换行。 s 非空，只包含从 a-z 的小写字母。 p 非空，只包含从 a-z 的小写字母，以及字符 ? 和 *。字符串s和p的长度均小于50

输出

每一组匹配串匹配成功输出‘yes’,否则输出‘no’。

样例输入

abc

a*c

abc

a??c

样例输出

yes

求逆序对数

对于一个长度为N的整数序列A，满足i < j 且 Ai > Aj.的数对(i,j)称为整数序列A的一个逆序 <j<=n且ai><j<=n且ai><j<=n且ai><j<=n且ai>

请求出整数序列A的所有逆序对个数

时间限制：500

内存限制：65536

输入

输入包含多组测试数据，每组测试数据有两行第一行为整数N(1 <= N <= 20000)，当输入0时结束第二行为N个整数，表示长为N的整数序列

输出

每组数据对应一行，输出逆序对的个数

样例输入

1 2 3 4 5

5 4 3 2 1

样例输出

分成互质组

给定n个正整数，将它们分组，使得每组中任意两个数互质。至少要分成多少个组？

时间限制：1000

内存限制：65536

输入

第一行是一个正整数n。1 <= n <= 10。第二行是n个不大于10000的正整数。

输出

一个正整数，即最少需要的组数。

样例输入

14 20 33 117 143 175

样例输出

3青少年软件编程（C语言）等级考试试卷（六级）

区间合并

给定 n 个闭区间 [ai; bi]，其中i=1,2,...,n。任意两个相邻或相交的闭区间可以合并为一个闭区间。例如，[1;2] 和 [2;3] 可以合并为 [1;3]，[1;3] 和 [2;4] 可以合并为 [1;4]，但是[1;2] 和 [3;4] 不可以合并。

我们的任务是判断这些区间是否可以最终合并为一个闭区间，如果可以，将这个闭区间输出，否则输出no。

时间限制：1000

内存限制：65536

输入

第一行为一个整数n，3 ≤ n ≤ 50000。表示输入区间的数量。之后n行，在第i行上（1 ≤ i ≤ n），为两个整数 ai 和 bi ，整数之间用一个空格分隔，表示区间 [ai; bi]（其中 1 ≤ ai ≤ bi ≤ 10000）。

输出

输出一行，如果这些区间最终可以合并为一个闭区间，输出这个闭区间的左右边界，用单个空格隔开；否则输出 no。

样例输入

5 6

1 5

10 10

6 9

8 10

样例输出

1 10

电话号码

给你一些电话号码，请判断它们是否是一致的，即是否有某个电话是另一个电话的前缀。比如： Emergency 911 Alice 97 625 999 Bob 91 12 54 26 在这个例子中，我们不可能拨通Bob的电话，因为Emergency的电话是它的前缀，当拨打Bob的电话时会先接通Emergency，所以这些电话号码不是一致的。

时间限制：1000

内存限制：65536

输入

第一行是一个整数t，1 ≤ t ≤ 40，表示测试数据的数目。每个测试样例的第一行是一个整数n，1 ≤ n ≤ 10000，其后n行每行是一个不超过10位的电话号码。

输出

对于每个测试数据，如果是一致的输出“YES”，如果不是输出“NO”。

样例输入

911

97625999

91125426

113

12340

123440

12345

98346

样例输出

YES

扑克牌排序

假设这里有36张扑克牌，分别为A1~A9,B1~B9,C1~C9,D1~D9，其中A代表方片，B代表草花，C代表红桃，D代表黑桃，那么，设定如下的排序规则：

1.对于两张卡牌，X1Y1与X2Y2，X1与X2表示A～D，Y1与Y2表示1～9，如果X1与X2不同，那么依照D>C>B>A的方式进行排序

2.假如有X1与X2相同时，那么就比较Y1与Y2的大小。

例如，对于如下的四张牌，有如下的升序排序结果：

D3，C4，A4，C1

升序排序的结果为A4，C1，C4，D3

有人提出了如下的排序策略：

先建立9个队列，用于存放点数的大小，将卡牌依点数存放入各自的队列之中，然后再按队列1到队列9依次出队。

例如，对于上面的结果，依次进队后，结果如下：

队列1：C1；队列3：D3，队列4：C4，A4

将其依次出队后，结果为C1，D3，C4，A4

然后，再建立4个队列，用于存放花色。将卡牌依花色A～D存放入队列1～4中，然后再按队列1到队列4依次出队。

例如，对于上面刚刚出队的序列C1，D3，C4，A4，将其依次进队，结果如下：

队列1：A4；队列3：C1，C4；队列4：D3

将其依次出队后，结果为A4，C1，C4，D3，排序结束。

请根据上面的算法，编写一个用队列对扑克牌排序的程序，要求依照上面的排序规则，根据先花色后点数的方法进行排序。

时间限制：1000

内存限制：65536

输入

输入分为两行，第一行为一个整数n，表示一共有n张牌（1<=n<=100）第二行用XY的形式表示每一张牌，其中X为A～D，Y为1～9

输出

输出三个部分第一个部分为第一次进队出队的结果，用Queue1:...表示，共9行，结果用空格分隔，下同第二部分为第二次进队出队的结果，用QueueA:...表示，共4行第三部分为一行，即将卡牌排序后的结果（升序排序）

样例输入

D8 A6 C3 B8 C5 A1 B5 D3

样例输出

Queue1:A1

Queue2:

Queue3:C3 D3

Queue4:

Queue5:C5 B5

Queue6:A6

Queue7:

Queue8:D8 B8

Queue9:

QueueA:A1 A6

QueueB:B5 B8

QueueC:C3 C5

QueueD:D3 D8

A1 A6 B5 B8 C3 C5 D3 D8

提示

第二次入队出队时，可以复用第一次时9个队列中的4个。所以其实只需要开辟9个队列即可。

现代艺术

在对二维艺术作品感到厌烦之后，伟大的艺术牛Picowso决定从事创作一项更为小众的艺术形式，一维画。

尽管目前她的画作可以用一个由颜色组成的长度为N(1~100000)的数组表示，但她的创作风格依然保持不变：从一张空白的矩形画布上，不断地画上一些矩形，在一维的情况下，这些矩形就只是一个区间。她用N种颜色，颜色编号为1~N进行创作，每种颜色只使用一次，之后使用的颜色可以完全的覆盖之前在相同位置上的颜色。

令Picowso感到十分沮丧的是，她的竞争对手Moonet似乎弄明白了如何复制她的这些一维画作，Moonet会画一些不相交的间隔，等待这些颜色晾干，然后再画另外的一些间隔，直到画完。Moonet每次每种颜色最多只能画一个间隔，但是他可以一次画不同颜色不相交的多个间隔，只要这些间隔没有重叠部分。之后Moonet再进行下一轮绘制。请计算Moonet为了复制一幅画需要画几个回合。

时间限制：10000

内存限制：65536

输入

第一行是一个整数N，之后N行包含了N个整数，范围0到N表示纸带每个格点的颜色，0表示没有涂色。

输出

输出一行，需要复制这幅画作的最少回合数，如果这幅画不可能是Picowso的画作输出-1（比如说这幅画不可能是通过一次在一条上画一层的方法进行创作的）

样例输入

样例输出

提示

在这个样例中，第一轮涂成0111133，第二轮涂成0145133，所以共需两轮。青少年软件编程（C语言）等级考试试卷（七级）

走迷宫

一个迷宫由R行C列格子组成，有的格子里有障碍物，不能走；有的格子是空地，可以走。给定一个迷宫，求从左上角走到右下角最少需要走多少步(数据保证一定能走到)。只能在水平方向或垂直方向走，不能斜着走。

时间限制：1000

内存限制：65536

输入

第一行是两个整数，Ｒ和Ｃ，代表迷宫的长和宽。（ 1<= R，C <= 40) 接下来是Ｒ行，每行Ｃ个字符，代表整个迷宫。空地格子用'.'表示，有障碍物的格子用'#'表示。迷宫左上角和右下角都是'.'。

输出

输出从左上角走到右下角至少要经过多少步（即至少要经过多少个空地格子）。计算步数要包括起点和终点。

样例输入

5 5

..###

#....

#.#.#

#.#..

样例输出

重建二叉树

给定一棵二叉树的前序遍历和中序遍历的结果，求其后序遍历。

时间限制：1000

内存限制：65536

输入

输入可能有多组，以EOF结束。每组输入包含两个字符串，分别为树的前序遍历和中序遍历。每个字符串中只包含大写字母且互不重复。

输出

对于每组输入，用一行来输出它后序遍历结果。

样例输入

DBACEGF ABCDEFG

BCAD CBAD

样例输出

ACBFGED

CDAB

快速堆猪

小明有很多猪，他喜欢玩叠猪游戏，就是将猪一头头叠起来。猪叠上去后，还可以把顶上的猪拿下来。小明知道每头猪的重量，而且他还随时想知道叠在那里的猪最轻的是多少斤。

时间限制：1000

内存限制：65536

输入

有三种输入 1)push n n是整数(0<=0 <=20000)，表示叠上一头重量是n斤的新猪 2)pop 表示将猪堆顶的猪赶走。如果猪堆没猪，就啥也不干 3)min 表示问现在猪堆里最轻的猪多重。如果猪堆没猪，就啥也不干输入总数不超过100000条

输出

对每个min输入，输出答案。如果猪堆没猪，就啥也不干

样例输入

pop

min

push 5

push 2

push 3

min

push 4

min

样例输出

表达式·表达式树·表达式求值

众所周知，任何一个表达式，都可以用一棵表达式树来表示。例如，表达式a+b*c，可以表示为如下的表达式树：

+ / \ a * / \ b c

现在，给你一个中缀表达式，这个中缀表达式用变量来表示（不含数字），请你将这个中缀表达式用表达式二叉树的形式输出出来。

时间限制：1000

内存限制：65535

输入

输入分为三个部分。第一部分为一行，即中缀表达式(长度不大于50)。中缀表达式可能含有小写字母代表变量（a-z），也可能含有运算符（+、-、*、/、小括号），不含有数字，也不含有空格。第二部分为一个整数n(n < 10)，表示中缀表达式的变量数。第三部分有n行，每行格式为C　x，C为变量的字符，x为该变量的值。

输出

输出分为三个部分，第一个部分为该表达式的逆波兰式，即该表达式树的后根遍历结果。占一行。第二部分为表达式树的显示，如样例输出所示。如果该二叉树是一棵满二叉树，则最底部的叶子结点，分别占据横坐标的第1、3、5、7……个位置（最左边的坐标是1），然后它们的父结点的横坐标，在两个子结点的中间。如果不是满二叉树，则没有结点的地方，用空格填充（但请略去所有的行末空格）。每一行父结点与子结点中隔开一行，用斜杠（/）与反斜杠（\）来表示树的关系。/出现的横坐标位置为父结点的横坐标偏左一格，\出现的横坐标位置为父结点的横坐标偏右一格。也就是说，如果树高为m，则输出就有2m-1行。第三部分为一个整数，表示将值代入变量之后，该中缀表达式的值。需要注意的一点是，除法代表整除运算，即舍弃小数点后的部分。同时，测试数据保证不会出现除以0的现象。

样例输入

a+b*c

a 2

b 7

c 5

样例输出

abc*+

/ \

a *

/ \

b c

37青少年软件编程（C语言）等级考试试卷（八级）

生理周期

人生来就有三个生理周期，分别为体力、感情和智力周期，它们的周期长度为23天、28天和33天。每一个周期中有一天是高峰。在高峰这天，人会在相应的方面表现出色。例如，智力周期的高峰，人会思维敏捷，精力容易高度集中。因为三个周期的周长不同，所以通常三个周期的高峰不会落在同一天。对于每个人，我们想知道何时三个高峰落在同一天。对于每个周期，我们会给出从当前年份的第一天开始，到出现高峰的天数（不一定是第一次高峰出现的时间）。你的任务是给定一个从当年第一天开始数的天数，输出从给定时间开始（不包括给定时间）下一次三个高峰落在同一天的时间（距给定时间的天数）。例如：给定时间为10，下次出现三个高峰同天的时间是12，则输出2（注意这里不是3）。

时间限制：1000

内存限制：65536

输入

一行，包含四个整数：p, e, i和d，相邻两个整数之间用单个空格隔开。 p, e, i分别表示体力、情感和智力高峰出现的时间（时间从当年的第一天开始计算）。d 是给定的时间，可能小于p, e, 或 i。所有给定时间是非负的并且小于等于365, 所求的时间小于等于21252。

输出

一个整数，即从给定时间起，下一次三个高峰同天的时间（距离给定时间的天数）。

样例输入

4 5 6 7

样例输出

16994

开关问题

有N个相同的开关，每个开关都与某些开关有着联系，每当你打开或者关闭某个开关的时候，其他的与此开关相关联的开关也会相应地发生变化，即这些相联系的开关的状态如果原来为开就变为关，如果为关就变为开。你的目标是经过若干次开关操作后使得最后N个开关达到一个特定的状态。对于任意一个开关，最多只能进行一次开关操作。你的任务是，计算有多少种可以达到指定状态的方法。（不计开关操作的顺序）

时间限制：1000

内存限制：65536

输入

输入第一行有一个数K，表示以下有K组测试数据。每组测试数据的格式如下：第一行一个数N（0 < N < 29）第二行 N个0或者1的数，表示开始时N个开关状态。第三行 N个0或者1的数，表示操作结束后N个开关的状态。接下来每行两个数I J，表示如果操作第 I 个开关，第J个开关的状态也会变化。每组数据以 0 0 结束。

输出

如果有可行方法，输出总数，否则输出“Oh,it's impossible~!!” 不包括引号

样例输入

0 0 0

1 1 1

1 2

1 3

2 1

2 3

3 1

3 2

0 0

0 0 0

1 0 1

1 2

2 1

0 0

样例输出

Oh,it's impossible~!!

提示

第一组数据的说明：一共以下四种方法：操作开关1 操作开关2 操作开关3 操作开关1、2、3 （不记顺序）

冰阔落 I

老王喜欢喝冰阔落。

初始时刻，桌面上有n杯阔落，编号为1到n。老王总想把其中一杯阔落倒到另一杯中，这样他一次性就能喝很多很多阔落，假设杯子的容量是足够大的。

有m 次操作，每次操作包含两个整数x与y。

若原始编号为x 的阔落与原始编号为y的阔落已经在同一杯，请输出"Yes"；否则，我们将原始编号为y 所在杯子的所有阔落，倒往原始编号为x 所在的杯子，并输出"No"。

最后，老王想知道哪些杯子有冰阔落。

时间限制：10000

内存限制：65536

输入

有多组测试数据，少于 5 组。每组测试数据，第一行两个整数 n, m (n, m<=50000)。接下来 m 行，每行两个整数 x, y (1<=x, y<=n)。

输出

每组测试数据，前 m 行输出 "Yes" 或者 "No"。第 m+1 行输出一个整数，表示有阔落的杯子数量。第 m+2 行有若干个整数，从小到大输出这些杯子的编号。

样例输入

3 2

1 2

2 1

4 2

1 2

4 3

样例输出

Yes

1 3

1 4

最短路

给定一个n个点, m条边的有向图, 求从点S出发, 到其它所有点的最短路径.

时间限制：2000

内存限制：65536

输入

第一行一个整数T, 表示有T组数据对于每组测试数据, 第一行三个整数n, m, S, 表示有n个点, m条边, 起点为S. 接下来m行, 每行三个整数x, y, z, 代表从x到y有长度为z的边点的编号从1到n T <= 10, n <= 10000, m <= 20000, |z| <= 10000. 所有数据的n之和 <= 30000, 所有数据的m之和 <= 60000.

输出

对于每组数据: 如果从S点出发可以走入负圈 (即到某些点的最短路径可以无限小), 那么输出一行Error. 否则, 输出一行用空格分隔的n个整数, 其中第i个整数表示从S点到i点的最短路长度. 如果从S点无法到达i点, 则第i个输出为”null”.

样例输入

5 7 1

1 2 3

2 3 4

3 4 8

1 3 9

4 5 1

1 4 5

1 5 10

4 4 1

1 2 -4

2 3 8

1 3 5

3 4 0

3 3 2

1 2 -3

2 3 -4

3 1 6

4 2 1

1 2 1

3 4 2

样例输出

0 3 7 5 6

0 -4 4 4

Error

0 1 null null青少年软件编程（C语言）等级考试试卷（一级）

分数：100 题数：5

一、编程题(共5题，共100分)

倒序输出依次输入4个整数a、b、c、d,将他们倒序输出，即依次输出d、c、b、a这4个数。时间限制：1000 内存限制：65536 输入一行4个整数a、b、c、d，以空格分隔。 0 < a,b,c,d < 108 输出一行4个整数d、c、b、a，整数之间以一个空格分隔。样例输入 1 2 3 4 样例输出 4 3 2 1 试题编号：20240323-1-01 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include<iostream> using namespace std; int main(){ int a,b,c,d; cin>>a>>b>>c>>d; cout<<d<<" "<<c<<" "<<b<<" "<<a; return 0; } 考生得分：20 是否评分：已评分评价描述：
足球联赛积分在足球联赛里，一个球队赢下一场比赛得到3个积分，打平一场比赛得到1个积分，输掉比赛得到0分。现已知一个球队在整个联赛里的比赛情况，求该球队最终的积分。时间限制：1000 内存限制：65536 输入三个整数x,y,z，以空格分开，分别表示这个球队赢下的比赛场数，打平的比赛场数，输掉的比赛场数。（0 ≤ x,y,z ≤ 40）输出一个整数，表示该球队最终的积分。样例输入 19 6 4 样例输出 63 提示 63=19*3+6*1+4*0 试题编号：20240323-1-02 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include<iostream> using namespace std; int main(){ int sum=0,x,y,z; cin>>x>>y>>z; sum+=x*3; sum+=y*1; sum+=z*0; cout<<sum; return 0; } 考生得分：20 是否评分：已评分评价描述：
苹果和虫子2 你买了一箱n个苹果，很不幸的是买完时箱子里混进了一条虫子。虫子每x小时能吃掉一个苹果，假设虫子在吃完一个苹果之前不会吃另一个，那么经过y小时你还有多少个完整的苹果？时间限制：1000 内存限制：65536 输入输入仅一行，包括n，x和y（均为整数）。输出输出也仅一行，剩下的苹果个数样例输入 10 4 9 样例输出 7 提示注意：是要求完整的苹果数。试题编号：20240323-1-03 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include<iostream> using namespace std; int main(){ int n,x,y; cin>>n>>x>>y; n=n-y*1.0/x; if(n<=0)n=0; cout<<n; return 0; } 考生得分：20 是否评分：已评分评价描述：
整数的个数给定k（1 < k < 100）个正整数，其中每个数都是大于等于1，小于等于10的数。写程序计算给定的k个正整数中，1，5和10出现的次数。时间限制：10000 内存限制：65536 输入输入有两行：第一行包含一个正整数k，第二行包含k个正整数，每两个正整数用一个空格分开。输出输出有三行，第一行为1出现的次数，，第二行为5出现的次数，第三行为10出现的次数。样例输入 5 1 5 8 10 5 样例输出 1 2 1 试题编号：20240323-1-04 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include<iostream> using namespace std; int main(){ int k,x,a=0,b=0,c=0; cin>>k; for(int i=1;i<=k;i++){ cin>>x; if(x==1)a+=1; if(x==5)b+=1; if(x==10)c+=1; } cout<<a<<endl; cout<<b<<endl; cout<<c<<endl; return 0; } 考生得分：20 是否评分：已评分评价描述：
求满足条件的3位数

编写程序，按从小到大的顺序寻找同时符合条件1和2的所有3位数，条件为： 1.该数为完全平方数 2.该数至少有2位数字相同例如，100同时满足上面两个条件。

时间限制：1000

内存限制：65536

输入

输入一个数n，n的大小不超过实际满足条件的3位数的个数。

输出

输出为第n个满足条件的3位数(升序)

样例输入

样例输出

100

试题编号：20240323-1-05

试题类型：编程题

标准答案：

试题难度：一般

试题解析：

展示地址：点击浏览

考生答案：

#include <bits/stdc++.h>

using namespace std;

int n, a, b, c, m, k;

int main() {

cin >> n;

for (int i = 100; i <= 999; i++) {

a = i / 100;

b = (i / 10) % 10;

c = i % 10;

k = sqrt(i);

if (a == b || a == c || b == c) {

if (k * k == i)

m++;

}

if (m == n) {

cout << i;

return 0;

}

return 0;

}

考生得分：20

是否评分：已评分

评价描述：青少年软件编程（C语言）等级考试试卷（二级）

分数：100 题数：5

一、编程题(共5题，共100分)

满足条件的数的累加2 现有n个整数，将其中个位数为k的数进行累加求和。时间限制：1000 内存限制：65536 输入第一行1个整数n。（ 0 < n < 1000）第二行n个非负整数，以空格分隔，每个数不大于100000。第三行1个整数k。(0 ≤ k ≤ 9) 输出输出满足题目要求的累加和。样例输入 10 2 5 7 17 11 18 4 27 1 7 7 样例输出 58 试题编号：20240323-2-01 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include<bits/stdc++.h> using namespace std; int main() { int n; cin>>n; int a[n+1]; for(int i=1;i<=n;i++) { cin>>a[i]; } int k; cin>>k; int sum=0; for(int i=1;i<=n;i++) { if(a[i]%10==k) { sum+=a[i]; } } cout<<sum; return 0; } 考生得分：20 是否评分：已评分评价描述：
统一文件名小A在命名文件的时候经常不注意大小写，格式比较混乱。现要求你写一个程序将目录下的文件统一规范的格式，即文件名的第一个字符如果是字母要大写，其他字母小写。如将Test、test整理成Test。时间限制：1000 内存限制：65536 输入第一行一个数字n，表示有n个文件名要统一，n不超过100。接下来n行，每行一个单词，长度不超过20，表示文件的名字。文件名由字母、数字和-组成。输出 n行，每行一个单词，对应统一后的文件名。样例输入 4 Test data 2-TEST problem-6 样例输出 Test Data 2-test Problem-6 试题编号：20240323-2-02 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案：（此题已作答）考生得分：0 是否评分：已评分评价描述：
Lab杯 “Lab杯”乒乓球赛就要在PKU的实验室之间举行了。人工智能实验室的学生都是乒乓球的狂热分子，都强烈希望代表实验室去比赛。但是有余名额限制，他们之中只能由一个人被选作代表。为了让选择的过程公平，他们决定打一次单循环赛，每一对学生之间都打一场五局三胜的比赛。赢得最多比赛的人就将代表实验室去比赛。现在Ava手里有一份表，表里面记录了每一场比赛的比分。她应该让谁去比赛？时间限制：5000 内存限制：131072 输入输入包含一组测试数据。第一行包含n（2 ≤ n ≤ 100），实验室里学生的数目。接下来给出一个n × n矩阵A。矩阵的每一个元素都是0、1、2、3中的一个。第i行第j列的元素aij是第i个学生在和第j个学生的比赛中赢的局数。aij和aji（i ≠ j）正好有一个是3，另外一个小于3。矩阵的所有对角线元素都是0。输出输出赢了最多比赛的学生的编号。如果有平分，选择编号最小的。样例输入 4 0 0 3 2 3 0 3 1 2 2 0 2 3 3 3 0 样例输出 4 试题编号：20240323-2-03 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include<bits/stdc++.h> using namespace std; int main(){ int n,score=-1,ans=0; cin>>n; for(int i=1;i<=n;i++){ int sum=0,x; for(int j=1;j<=n;j++){ cin>>x; if(x>=3) sum++; } if(sum>score){ score=sum; ans=i; } } cout<<ans<<endl; return 0; } 考生得分：20 是否评分：已评分评价描述：
整数排序给定10个整数的序列，要求对其重新排序。排序要求: 1.奇数在前，偶数在后； 2.奇数按从大到小排序； 3.偶数按输入顺序逆序排序。时间限制：1000 内存限制：65536 输入输入一行，包含10个整数，彼此以一个空格分开，每个整数的范围是大于等于0，小于等于100。输出按照要求排序后输出一行，包含排序后的10个整数，数与数之间以一个空格分开。样例输入 4 7 3 13 11 12 0 47 34 98 样例输出 47 13 11 7 3 98 34 0 12 4 试题编号：20240323-2-04 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include<bits/stdc++.h> using namespace std; bool f(int a,int b) { return a>b; } int main() { int a[10],b[10],c[10]; int j,k; j=k=0; for(int i=0;i<10;i++) { cin>>a[i]; } for(int i=0;i<10;i++) { if(a[i]%2!=0) { b[j++]=a[i]; } else { c[k++]=a[i]; } } sort (b,b+j,f); for(int i=0;i<j;i++) { cout<<b[i]<<" " ; } for(int i=k-1;i>=0;i--) { cout<<c[i]<<" "; } return 0; }考生得分：20 是否评分：已评分评价描述：
石头剪刀布

石头剪刀布是常见的猜拳游戏。石头胜剪刀，剪刀胜布，布胜石头。如果两个人出拳一样，则不分胜负。

一天，小A和小B正好在玩石头剪刀布。已知他们的出拳都是有周期性规律的，比如：“石头-布-石头-剪刀-石头-布-石头-剪刀……”，就是以“石头-布-石头-剪刀”为周期不断循环的。请问，小A和小B比了N轮之后，谁赢的轮数多？

时间限制：1000

内存限制：65536

输入

输入包含三行。第一行包含三个整数：N，NA，NB，分别表示比了N轮，小A出拳的周期长度，小B出拳的周期长度。0 < N,NA,NB < 100。第二行包含NA个整数，表示小A出拳的规律。第三行包含NB个整数，表示小B出拳的规律。其中，0表示“石头”，2表示“剪刀”，5表示“布”。相邻两个整数之间用单个空格隔开。

输出

输出一行，如果小A赢的轮数多，输出A；如果小B赢的轮数多，输出B；如果两人打平，输出draw。

样例输入

10 3 4

0 2 5

0 5 0 2

样例输出

提示

对于测试数据，猜拳过程为： A：0 2 5 0 2 5 0 2 5 0 B：0 5 0 2 0 5 0 2 0 5 A赢了4轮，B赢了2轮，双方打平4轮，所以A赢的轮数多。

试题编号：20240323-2-05

试题类型：编程题

标准答案：

试题难度：一般

试题解析：

展示地址：点击浏览

考生答案：

考生得分：0

是否评分：已评分

评价描述：青少年软件编程（C语言）等级考试试卷（三级）

分数：100 题数：5

一、编程题(共5题，共100分)

我家的门牌号我家的门牌号我家住在一条短胡同里，这条胡同的门牌号从1开始顺序编号。若所有的门牌号之和减去我家门牌号的两倍，恰好等于n，求我家的门牌号及总共有多少家。数据保证有唯一解。时间限制：1000 内存限制：65536 输入一个正整数n。n < 100000。输出一行，包含两个正整数，分别是我家的门牌号及总共有多少家，中间用单个空格隔开。样例输入 100 样例输出 10 15 试题编号：20240323-3-01 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include<iostream> using namespace std; int main(){ int a; cin>>a; for(int i=1;i<100000;i++){ for(int j=1;j<=i;j++){ if((i+1)*i/2-j*2==a){ cout<<j<<' '<<i; return 0; } } } } 考生得分：20 是否评分：已评分评价描述：
最接近的分数分母不超过 N 且小于 A/B 的最大最简分数是多少？时间限制：10000 内存限制：65536 输入三个正整数N，A，B，相邻两个数之间用单个空格隔开。1 <= A < B < N <= 1000。输出两个正整数，分别是所求分数的分子和分母，中间用单个空格隔开。样例输入 100 7 13 样例输出 50 93 试题编号：20240323-3-02 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案：（此题已作答）考生得分：0 是否评分：已评分评价描述：
菲波那契数列菲波那契数列是指这样的数列: 数列的第一个和第二个数都为1，接下来每个数都等于前面2个数之和。给出一个正整数a，要求菲波那契数列中第a个数对10000取模的结果是多少。时间限制：1000 内存限制：65536 输入第1行是测试数据的组数n，后面跟着n行输入。每组测试数据占1行，包括一个正整数a(1 <= a <= 1000000)。输出 n行，每行输出对应一个输入。输出应是一个正整数，为菲波那契数列中第a个数对10000取模得到的结果。样例输入 4 5 2 19 1 样例输出 5 1 4181 1 试题编号：20240323-3-03 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案：（此题已作答）考生得分：0 是否评分：已评分评价描述：
表达式求值输入一个布尔表达式，请你输出它的真假值。比如：( V | V ) & F & ( F | V ) V表示true，F表示false，&表示与，|表示或，!表示非。上式的结果是F 时间限制：1000 内存限制：65536 输入输入包含多行，每行一个布尔表达式，表达式中可以有空格，总长度不超过1000 输出对每行输入，如果表达式为真，输出"V",否则出来"F" 样例输入 ( V | V ) & F & ( F| V) !V | V & V & !F & (F | V ) & (!F | F | !V & V) (F&F|V|!V&!F&!(F|F&V)) 样例输出 F V V 试题编号：20240323-3-04 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案：（此题已作答）考生得分：0 是否评分：已评分评价描述：
广义格雷码

在一组数的编码中，若任意两个相邻（首尾也视为相邻）的代码只有一位二进制数不同，则称这种编码为格雷码。如四位格雷码：

0000、0001、0011、0010、0110、0111、0101、0100、1100、1101、1111、1110、1010、1011、1001、1000

现在将格雷码扩展至其他进制，仍然是相邻两个数只能有一位不同。输入两个正整数n,m分别表示长度和进制，每行输出一个n位m进制数，输出任意一种编码即可。（提示：putchar输出效率更高）

时间限制：1000

内存限制：65536

输入

一行，两个整数n,m。其中 2 ≤ n ≤ 12 ,2 ≤ m ≤ 10 且mn ≤ 500000

输出

任意一种编码方案，每个编码一行。相邻两个编码相差一位。第一个编码和最后一个编码算相邻

样例输入

2 3

样例输出

试题编号：20240323-3-05

试题类型：编程题

标准答案：

试题难度：一般

试题解析：

展示地址：点击浏览

考生答案：

考生得分：0

是否评分：已评分

评价描述：青少年软件编程（C语言）等级考试试卷（四级）

分数：100 题数：4

一、编程题(共4题，共100分)

最长上升子序列一个数的序列bi，当b1 < b2 < ... < bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, ..., aN)，我们可以得到一些上升的子序列(ai1, ai2, ..., aiK)，这里1 <= i1 < i2 < ... < iK <= N。比如，对于序列(1, 7, 3, 5, 9, 4, 8)，有它的一些上升子序列，如(1, 7), (3, 4, 8)等等。这些子序列中最长的长度是4，比如子序列(1, 3, 5, 8). 你的任务，就是对于给定的序列，求出最长上升子序列的长度。时间限制：11000 内存限制：65536 输入输入的第一行是序列的长度N (1 <= N <= 1000)。第二行给出序列中的N个整数，这些整数的取值范围都在0到10000。输出最长上升子序列的长度。样例输入 7 1 7 3 5 9 4 8 样例输出 4 试题编号：20240323-4-01 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案：考生得分：0 是否评分：已评分评价描述：
重启系统小明帮助管理一个处理数据的计算系统，有N个待处理的任务，需要按照顺序来完成这些任务，即每次所完成任务的编号都要大于前一个完成任务的编号，且单个任务不可以分解完成。计算系统运行着一个奇怪的保护程序，它限制了系统当前所能处理的数据量不能超过上次完成任务所处理的数据量。重启系统可以使它立刻恢复到最高性能（一开始系统拥有最高性能，最高性能大于任何待处理任务的数据量）。小明有一次重启系统的权限（也可以不使用），你能帮他算出最多能完成几个任务吗？时间限制：1000 内存限制：65536 输入第一行： N (2 <= N <= 1000) 待处理的任务数第二行： N个整数，每个任务的数据量输出输出只包括一行，这一行只包含一个整数，表示最多能完成的任务数。样例输入 10 1 5 4 3 2 10 9 8 7 6 样例输出 9 提示回想一下最长上升子序列问题试题编号：20240323-4-02 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案：（此题已作答）考生得分：0 是否评分：已评分评价描述：
硬币宇航员Bob有一天来到火星上，他有收集硬币的习惯。于是他将火星上所有面值的硬币都收集起来了，一共有n种，每种只有一个：面值分别为a1,a2… an。 Bob在机场看到了一个特别喜欢的礼物，想买来送给朋友Alice，这个礼物的价格是X元。Bob很想知道为了买这个礼物他的哪些硬币是必须被使用的，即Bob必须放弃收集好的哪些硬币种类。飞机场不提供找零，只接受恰好X元。时间限制：1000 内存限制：262144 输入第一行包含两个正整数n和x。（1 <= n <= 200, 1 <= x <= 10000) 第二行从小到大为n个正整数a1, a2, a3 … an （1 <= ai <= 10000) 输出第一行是一个整数，即有多少种硬币是必须被使用的。第二行是这些必须使用的硬币的面值（从小到大排列）。样例输入 5 18 1 2 3 5 10 样例输出 2 5 10 提示输入数据将保证给定面值的硬币中至少有一种组合能恰好能够支付X元。如果不存在必须被使用的硬币，则第一行输出0，第二行输出空行。试题编号：20240323-4-03 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案：考生得分：0 是否评分：已评分评价描述：
奶牛散步

从一个无限大的矩阵的中心点出发，一步只能向右走、向上走或向左走。恰好走N步且不经过已走的点共有多少种走法？

时间限制：10000

内存限制：131072

输入

一个数字，代表N,N<=1000

输出

输出有多少方案, 答案模12345

样例输入

样例输出

试题编号：20240323-4-04

试题类型：编程题

标准答案：

试题难度：一般

试题解析：

展示地址：点击浏览

考生答案：

考生得分：0

是否评分：已评分

评价描述：青少年软件编程（C语言）等级考试试卷（五级）

分数：100 题数：4

一、编程题(共4题，共100分)

逃离迷宫你在一个地下迷宫中找到了宝藏，但是也触发了迷宫机关，导致迷宫将在T分钟后坍塌，为此你需要在T分钟内逃离迷宫，你想知道你能不能逃离迷宫。迷宫是一个边长为m的正方形，其中"S"表示你所在的位置，"E"表示迷宫出口，"."是可以随意走动的区域，"#"是不可穿行的墙壁，每次你可以耗费1分钟在区域间移动（上下左右四个方向）。时间限制：1000 内存限制：65536 输入输入包含多组数组，第一行是一个整数K（1 <= K <= 10)，表示有K组数据。接下来每组数组包含整数m(2<=m<=10)和整数T，m表示正方形迷宫的边长，T表示坍塌时间。其后是一个m*m的字符矩阵，包含字符"S", "E", "."和"#"。输出每组数据输出一行，输出“YES"或者"NO"，表示是否可以在坍塌之前逃离（也就是说移动次数是否可以不超过T）。样例输入 2 4 7 S... ###. .#E. ..#. 3 4 S.. ..# .#E 样例输出 YES NO 试题编号：20240323-5-01 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include <bits/stdc++.h> using namespace std; char map_[12][12]; int x[4]={-1,1,0,0}; int y[4]={0,0,-1,1}; int k,m,t,sign; void dfs(int a,int b,int n){ if(n>t) return; for(int i=0;i<4;i++){ int aa=a+x[i]; int bb=b+y[i]; if(aa>=1&&aa<=m&&bb>=1&&bb<=m){ if(map_[aa][bb]=='.'){ map_[aa][bb]='#'; dfs(aa,bb,n+1); map_[aa][bb]='.'; } else if(map_[aa][bb]=='E'){ sign=1;return; } } } } int main() { int x1,y1; cin>>k; while(k--){ cin>>m>>t; for(int i=1;i<=m;i++) for(int j=1;j<=m;j++){ cin>>map_[i][j]; if(map_[i][j]=='S'){ x1=i;y1=j; } } sign=0; dfs(x1,y1,1); if(sign) cout<<"YES"<<endl; else cout<<"NO"<<endl; } return 0; } 考生得分：25 是否评分：已评分评价描述：
密室逃脱小Y喜欢玩密室逃脱，每次游戏开始时，小Y会进入一个密室，她需要按照顺序解开各个隐藏线索才能成功逃脱密室。小Y非常聪明，解开线索对她来说并不难，但是她有一点懒，她希望在通关过程中移动次数最少。请你帮小Y计算她至少要移动多少次才能成功通关。密室是m行n列的格子矩阵，小Y从左上角(1,1)进入密室，密室中有三种格子: 墙，以数字0标记路，以数字1标记隐藏线索处，以数字( > 1)标记, 代表该线索的难度小Y需要按照难度递增的顺序解开各个线索，逃脱密室。时间限制：1000 内存限制：65536 输入第一行是一个整数 T，表示输入包含 T 组数据，分别是不同的游戏中小Y所处的密室。对于每组数据，第一行包括两个整数：m（1 <= m <= 100）、n（1 <= n <= 100）。接下来 m 行，每行有n个数字，第 i 行的第 j 个数字表示密室中第 i 行第 j 列的格子的类型。题目保证进入密室处(1,1)不是墙壁，线索的难度都不相同。输出对于每组数据，你需要输出一个整数，表示小Y在这个密室中至少要移动多少次才能成功通关。如果小Y不可能解开所有线索，输出-1. 样例输入 2 3 3 1 3 2 1 0 4 10 6 5 3 3 1 3 2 0 0 0 10 6 5 样例输出 8 -1 提示样例解释：由于需要按难度顺序解开线索，在第一组数据中，小Y第一次移动到3时不能解密，在完成2之后需要回到3.最后小Y解开10时，她成功通关。试题编号：20240323-5-02 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include <iostream> #include <algorithm> #include <queue> #include <cstring> using namespace std; int m,n; int maze[104][104] = {}; int dx[4] = {0,0,-1,1}; int dy[4] = {-1,1,0,0}; bool legal(int x, int y){ if(0 <= x && x< m && 0 <= y && y < n && maze[x][y] != 0) return 1; return 0; } struct Node{ int x, y, k, t; }; int main() { int T; cin >> T; while(T--){ memset(maze, 0, sizeof(maze)); int vis[104][104] = {}; memset(vis, 0xff, sizeof(vis)); int S[10050] = {}; int cnt = 0; cin >> m >> n; for(int i = 0; i < m; ++i){ for(int j = 0; j < n; ++j){ cin >> maze[i][j]; if (maze[i][j] > 1) { S[cnt++] = maze[i][j]; } } } queue<Node> open; sort(S, S + cnt); if (maze[0][0] == S[0]) { open.push({0, 0, 1, 0}); vis[0][0] = 1; } else { open.push({0, 0, 0, 0}); vis[0][0] = 0; } bool flag = 0; while (!open.empty()) { Node temp = open.front(); open.pop(); if (temp.k == cnt) { flag = 1; cout << temp.t << endl; break; } for (int i = 0; i < 4; i++) { int x = temp.x + dx[i], y = temp.y + dy[i], k = temp.k; if (!legal(x,y)) continue; if (maze[x][y] == S[k]) k++; if (vis[x][y] >= k) continue; vis[x][y] = k; open.push({x, y, k, temp.t + 1}); } } if (!flag) cout << -1 << endl; } return 0; } 考生得分：25 是否评分：已评分评价描述：
交易市场市场里面一共有n种物品，有m种交易途径，每个交易途径可以由(x,y,z)表示，意思是可以用第x种物品换成第y种物品，并且得到z元的收益（z均大于0）。最开始你只有第一种物品，请问最多可以赚取多少收益。时间限制：1000 内存限制：65536 输入第一行两个正整数n和m(n ≤ 1000，m ≤ 4000) 接下来m行，每行三个正整数x, y, z，意思是可以用第x种物品换成第y种物品，并且得到z元的收益。（1 ≤ x,y ≤ n, 1 ≤ z ≤ 100）输出一个整数表示最大收益，如果可以赚取无穷多的收益则输出1000000000 样例输入 3 3 1 2 2 2 3 3 1 3 4 样例输出 5 试题编号：20240323-5-03 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include <iostream> #include <vector> #include <map> #include <set> #include <cstring> #include <algorithm> #include <queue> #define INF 1000000000 using namespace std; struct exchangeTo { int target; int p; exchangeTo(int a, int b) :target(a), p(b) {} }; struct path { int pre; int val; }dp[1005]; map<int, vector<exchangeTo> >tables; bool inPath(int n, int k) { while (k != -1) { if (n == k) return true; k = dp[k].pre; } return false; } int main() { memset(dp, -1, sizeof(dp)); int n, m; cin >> n >> m; for (int i = 0; i < m; i++) { int x, y, z; cin >> x >> y >> z; tables[x].push_back(exchangeTo(y, z)); } dp[1].val = 0, dp[1].pre = 0; bool done = false; int result = 0; queue<int>myqueues; myqueues.push(1); while (!myqueues.empty()) { int top = myqueues.front(); myqueues.pop(); if (!tables[top].empty()) { vector<exchangeTo>::iterator ii; for (ii = tables[top].begin(); ii != tables[top].end(); ii++) { if (inPath(ii->target, top)) { result = INF; done = true; break; } if (dp[top].val + ii->p > dp[ii->target].val) { dp[ii->target].val = dp[top].val + ii->p; dp[ii->target].pre = top; myqueues.push(ii->target); } result = max(result, dp[ii->target].val); } if (done)break; } } cout << result << endl; return 0; } 考生得分：25 是否评分：已评分评价描述：
求逆序对问题

给定N个数的序列a1,a2,...aN，定义一个数对(ai, aj)为“重要逆序对”的充要条件为 i < j 且 ai > 2aj。求给定序列中“重要逆序对”的个数。

时间限制：1000

内存限制：256000

输入

本题有多个测试点，每个测试点分为两行：第一行为序列中数字的个数N（1 ≤ N ≤ 200000），第二行为序列a1, a2 ... aN(0 ≤a ≤ 10000000)，由空格分开。N=0表示输入结束。

输出

每个测试点一行，输出一个整数，为给序列中“重要逆序对”的个数。

样例输入

0 9 8 7 6 5 4 3 2 1

样例输出

提示

请注意答案范围，如果使用printf输出long long类型，请用%lld

试题编号：20240323-5-04

试题类型：编程题

标准答案：

试题难度：一般

试题解析：

展示地址：点击浏览

考生答案：

#include <iostream>

using namespace std;

int arr[200005];

int tmp[200005];

int N;

long long mergesort(int start,int end){

long long cnt=0, mid=(start+end)/2;

if(start>=end) return 0;

cnt+=mergesort(start,mid);

cnt+=mergesort(mid+1,end);

int i=start,j=mid+1;

while(i<=mid && j<=end){

if(arr[i]>2*arr[j] && j<=end){

cnt+=(mid-i+1);

j++;

}else{

i++;

}

i=start,j=mid+1;

int idx=0;

while(i<=mid && j<=end){

if(arr[i]>arr[j]){

tmp[idx++]=arr[j++];

}else{

tmp[idx++]=arr[i++];

}

while(i<=mid) tmp[idx++]=arr[i++];

while(j<=end) tmp[idx++]=arr[j++];

for(int k=0;k<idx;k++){

arr[start+k]=tmp[k];

}

return cnt;

}

int main(){

while(cin>>N){

if(N==0) break;

for(int i=1;i<=N;i++){

cin>>arr[i];

}

cout<<mergesort(1,N)<<endl;

}

return 0;

}

考生得分：25

是否评分：已评分

评价描述：青少年软件编程（C语言）等级考试试卷（六级）

分数：100 题数：4

一、编程题(共4题，共100分)

小白鼠再排队 N只小白鼠(1 < N < 100)，每只鼠头上戴着一顶有颜色的帽子。现在称出每只白鼠的重量，要求按照白鼠重量从小到大的顺序输出它们头上帽子的颜色。帽子的颜色用 “red”，“blue”等字符串来表示。不同的小白鼠可以戴相同颜色的帽子。白鼠的重量用整数表示。时间限制：1000 内存限制：65536 输入输入第一行为一个整数N，表示小白鼠的数目。下面有N行，每行是一只白鼠的信息。第一个为正整数，表示白鼠的重量，不超过整型范围；第二个为字符串，表示白鼠的帽子颜色，字符串长度不超过10个字符。注意：白鼠的重量各不相同。输出按照白鼠的重量从小到大的顺序输出白鼠的帽子颜色。样例输入 3 30 red 50 blue 40 green 样例输出 red green blue 试题编号：20240323-6-01 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include <bits/stdc++.h> using namespace std; struct shu { int n; string s; }a[100010]; bool cmp(shu a,shu b) { return a.n<b.n; } int main() { int N; cin>>N; for(int i=0;i<N;i++) { cin>>a[i].n>>a[i].s; } sort(a,a+N,cmp); for(int i=0;i<N;i++) { cout<<a[i].s<<endl; } } 考生得分：25 是否评分：已评分评价描述：
扩号匹配问题在某个字符串（长度不超过100）中有左括号、右括号和大小写字母；规定（与常见的算数式子一样）任何一个左括号都从内到外与在它右边且距离最近的右括号匹配。写一个程序，找到无法匹配的左括号和右括号，输出原来字符串，并在下一行标出不能匹配的括号。不能匹配的左括号用"$"标注,不能匹配的右括号用"?"标注. 时间限制：3000 内存限制：65536 输入输入包括多组数据，每组数据一行，包含一个字符串，只包含左右括号和大小写字母，字符串长度不超过100 输出对每组输出数据，输出两行，第一行包含原始输入字符，第二行由"$","?"和空格组成，"$"和"?"表示与之对应的左括号和右括号不能匹配。样例输入 ((ABCD(x) )(rttyy())sss)( 样例输出 ((ABCD(x) $$ )(rttyy())sss)( ? ?$ 试题编号：20240323-6-02 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include <bits/stdc++.h> using namespace std; char a[101],b[101]; int up(int c) { if(c==-1) return -1; else if(b[c]=='$') return c; else return up(c-1); } int main() { while(scanf("%s",a)!=-1) { printf("%s\n",a); int n=strlen(a); memset(b,' ',sizeof(b)); for(int i=0;i<n;i++) { if(a[i]=='(') b[i]='$'; else if(a[i]==')') { int m=up(i-1); if(m==-1) b[i]='?'; else b[m]=' '; } } printf("%s\n",b); } return 0; } 考生得分：25 是否评分：已评分评价描述：
stack or queue 栈和队列都是常用的线性结构，它们都提供两个操作： Push：加入一个元素。 Pop：弹出一个元素。不同的是，栈是”先进后出”，而队列则是”先进先出”。给出一个线性结构的进出顺序，判定这个结构是栈还是队列。时间限制：1000 内存限制：65535 输入第一行输入一个整数t，代表有t组测试数据对于每组测试数据，第一行输入一个整数n，代表操作的次数。随后输入n行，每行包含两个整数 type val。当type = 1时，表示该次操作为push操作，val表示进入的数字。当type=2时，表示该次操作为pop操作，val代表出来的数字。 3<=n<=2000 输出每组测试数据输出一行。输出该组数据对应的线性结构，”Stack” 或者 “Queue”。题目保证是栈或者队列的一种。样例输入 2 6 1 1 1 2 1 3 2 3 2 2 2 1 4 1 1 1 2 2 1 2 2 样例输出 Stack Queue 试题编号：20240323-6-03 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include <bits/stdc++.h> using namespace std; string Struct; bool H; int push[2005]; int pop[2005]; int main() { int t; cin>>t; while(t--) { int n,type,val,Innum=0,Outnum=0; cin>>n; for(int i=0;i<n;++i) { cin>>type>>val; if(type==1) { push[Innum++]=val; } else { pop[Outnum++]=val; } } int num=min(Innum,Outnum); H=false; for(int i=0;i<num;++i) { if(push[i]!=pop[i]) { Struct="Stack"; H=true; break; } } if(!H) Struct="Queue"; cout<<Struct<<endl; } return 0; } 考生得分：25 是否评分：已评分评价描述：
利用队列进行数字排序

对于N个数字，有人提出了如下的排序策略：

例如，对于数字53、47、85、38、64、23

先建立10个队列(0到9），用于存放数字的大小，将这N个数字依个位存放入各自的队列之中，然后再按队列0到队列9依次出队。

例如，对于上面的数字，依次进队后，结果如下：

队列3：53、23　队列4：64　队列5：85　队列7：47　队列8：38

将其依次出队后，结果为53,23,64,85,47,38

然后，再将方才出队后的队对，依照十位放入各自的队列之中，然后再按队列0到队列9依次出队

例如，对于上面刚刚出队的序列53,23,64,85,47,38，将其依次进队，结果如下：

队列2：23　队列3：38　队列4：47　队列5：53　队列6：64　队列8：85

将其依次出队后，结果为23,38,47,53,64,85.因为这组数字最大只是两位数，所以排序结束。

如果还有更大的数字，那么，接下来就是其百位、千位……（如果位数不够，就补0.比如最大的数字是四位数，那么数字23就当成0023处理）

请根据上述算法，对这些数字进行排序

时间限制：1000

内存限制：65535

输入

分为两行，第一行为一个数字N(1 <= N <= 1000)，表示数字的个数第二行为N个数字（都是非负数），以空格相隔，最大的数字不超过9999

输出

输出两个部分第一个部分为第一次进队出队的结果，先显示一行：Step1. 之后用Queue0:...表示，共10行，结果用空格分隔，下同之后为第二次进队出队的结果（如果需要第二次进队出队的话），先显示一行：Step2. 之后仍然用Queue0:...表示，共10行之后如果需要的话，则分别显示第三次、第四次的进队出队结果第二部分为一行，即将数字排序后的结果（升序排序）

样例输入

41 67 34 0 69 24 78 58 62 64 5 45 81 27 61 91 95 42 27 36

样例输出

Step1.

Queue0:0

Queue1:41 81 61 91

Queue2:62 42

Queue3:

Queue4:34 24 64

Queue5:5 45 95

Queue6:36

Queue7:67 27 27

Queue8:78 58

Queue9:69

Step2.

Queue0:0 5

Queue1:

Queue2:24 27 27

Queue3:34 36

Queue4:41 42 45

Queue5:58

Queue6:61 62 64 67 69

Queue7:78

Queue8:81

Queue9:91 95

0 5 24 27 27 34 36 41 42 45 58 61 62 64 67 69 78 81 91 95

试题编号：20240323-6-04

试题类型：编程题

标准答案：

试题难度：一般

试题解析：

展示地址：点击浏览

考生答案：

#include<bits/stdc++.h>

using namespace std;

int get_digit_number(int x, int i)

{

int tmp = pow(10, i);

x /= tmp;

return x % 10;

}

int how_many_digits(int x)

{

int ret = 1;

while ((x /= 10) != 0)

++ret;

return ret;

}

vector<int> q[5][10];

int main()

{

int n;

int max_digits = 0;

cin >> n;

for (int i = 0; i < n; ++i)

{

int t; cin >> t;

max_digits = max(max_digits, how_many_digits(t));

q[0][t % 10].push_back(t);

}

ostringstream sout;

for (int i = 1; i <= max_digits; ++i)

{

printf("Step%d.\n", i);

for (int j = 0; j < 10; ++j)

{

printf("Queue%d:", j);

for (int e : q[i-1][j])

{

printf("%d ", e);

if (i == max_digits)

sout << e << " ";

else

q[i][get_digit_number(e, i)].push_back(e);

}

printf("\n");

}

cout << sout.str() << endl;

return 0;

}

考生得分：25

是否评分：已评分

评价描述：青少年软件编程（C语言）等级考试试卷（七级）

分数：100 题数：4

一、编程题(共4题，共100分)

走出迷宫当你站在一个迷宫里的时候，往往会被错综复杂的道路弄得失去方向感，如果你能得到迷宫地图，事情就会变得非常简单。假设你已经得到了一个n*m的迷宫的图纸，请你找出从起点到出口的最短路。时间限制：1000 内存限制：65536 输入第一行是两个整数n和m(1<=n,m<=100)，表示迷宫的行数和列数。接下来n行，每行一个长为m的字符串，表示整个迷宫的布局。字符'.'表示空地，'#'表示墙，'S'表示起点,'T'表示出口。输出输出从起点到出口最少需要走的步数。样例输入 3 3 S#T .#. ... 样例输出 6 试题编号：20240323-7-01 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案：（此题已作答）考生得分：0 是否评分：已评分评价描述：
有多少种二叉树输入n(1<n<13)，求n个结点的二叉树有多少种形态时间限制：1000 内存限制：65536 输入整数n 输出答案样例输入 3 样例输出 5 试题编号：20240323-7-02 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案： #include<bits/stdc++.h> using namespace std; int main(){ long long n,n1=1,y=0; cin>>n; for(long long i=1;i<n+1;i++){ y=(4*i-2)*n1/(i+1); n1=y; } cout<<y; return 0; } 考生得分：25 是否评分：已评分评价描述：
迷宫问题定义一个二维数组： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。时间限制：1000 内存限制：65536 输入一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。输出左上角到右下角的最短路径，格式如样例所示。样例输入 0 1 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 1 0 样例输出 (0, 0) (1, 0) (2, 0) (2, 1) (2, 2) (2, 3) (2, 4) (3, 4) (4, 4) 试题编号：20240323-7-03 试题类型：编程题标准答案：试题难度：一般试题解析：展示地址：点击浏览考生答案：（此题已作答）考生得分：0 是否评分：已评分评价描述：
快速堆猪

时间限制：1000

内存限制：65536

输入

输出

对每个min输入，输出答案。如果猪堆没猪，就啥也不干

样例输入

pop

min

push 5

push 2

push 3

min

push 4

min

样例输出

试题编号：20240323-7-04

试题类型：编程题

标准答案：

试题难度：一般

试题解析：

展示地址：点击浏览

考生答案：（此题已作答）

考生得分：0

是否评分：已评分

评价描述：1、道路

N个以 1 ... N 标号的城市通过单向的道路相连:。每条道路包含两个参数：道路的长度和需要为该路付的通行费（以金币的数目来表示）

Bob and Alice 过去住在城市 1.在注意到Alice在他们过去喜欢玩的纸牌游戏中作弊后，Bob和她分手了，并且决定搬到城市N。他希望能够尽可能快的到那，但是他囊中羞涩。我们希望能够帮助Bob找到从1到N最短的路径，前提是他能够付的起通行费。

时间限制：1000

内存限制：65536

输入

第一行包含一个整数K, 0 <= K <= 10000, 代表Bob能够在他路上花费的最大的金币数。第二行包含整数N， 2 <= N <= 100, 指城市的数目。第三行包含整数R, 1 <= R <= 10000, 指路的数目. 接下来的R行，每行具体指定几个整数S, D, L 和 T来说明关于道路的一些情况，这些整数之间通过空格间隔: S is 道路起始城市, 1 <= S <= N D is 道路终点城市, 1 <= D <= N L is 道路长度, 1 <= L <= 100 T is 通行费 (以金币数量形式度量), 0 <= T <=100 注意不同的道路可能有相同的起点和终点。

输出

输入结果应该只包括一行，即从城市1到城市N所需要的最小的路径长度（花费不能超过K个金币）。如果这样的路径不存在，结果应该输出-1。

样例输入

1 2 2 3

2 4 3 3

3 4 2 4

1 3 4 1

4 6 2 1

3 5 2 0

5 4 3 2

样例输出

2、Freda的越野跑

Freda报名参加了学校的越野跑。越野跑共有N人参加，在一条笔直的道路上进行。这N个人在起点处站成一列，相邻两个人之间保持一定的间距。比赛开始后，这N个人同时沿着道路向相同的方向跑去。换句话说，这N个人可以看作x轴上的N个点，在比赛开始后，它们同时向x轴正方向移动。假设越野跑的距离足够远，这N个人的速度各不相同且保持匀速运动，那么会有多少对参赛者之间发生“赶超”的事件呢？

时间限制：1000

内存限制：262144

输入

第一行1个整数N。第二行为N 个非负整数，按从前到后的顺序给出每个人的跑步速度。对于50%的数据，2<=N<=1000。对于100%的数据，2<=N<=100000。

输出

一个整数，表示有多少对参赛者之间发生赶超事件。

样例输入

1 3 10 8 5

样例输出

提示

我们把这5个人依次编号为A,B,C,D,E，速度分别为1,3,10,8,5。在跑步过程中： B,C,D,E均会超过A，因为他们的速度都比A快； C,D,E都会超过B，因为他们的速度都比B快； C,D,E之间不会发生赶超，因为速度快的起跑时就在前边。

3、Rainbow的商店