第1题：找和为K的两个元素
在一个长度为n(n < 1000)的整数序列中，判断是否存在某两个元素之和为k。
时间限制：1000
内存限制：65536
输入
第一行输入序列的长度n和k，用空格分开。 第二行输入序列中的n个整数，用空格分开。
输出
如果存在某两个元素的和为k，则输出yes，否则输出no。
样例输入
9 10
1 2 3 4 5 6 7 8 9
样例输出
yes
要解决这个问题，可以使用双重循环来遍历所有可能的元素对，判断它们的和是否等于给定的目标值k。
以下是解题的基本思路：
（1）读取输入的序列长度n和目标和k。
（2）创建一个长度为n的整数数组，用于存储输入的序列。
（3）使用一个外部循环，遍历数组中的每个元素，假设当前元素为nums[i]。
（4）在外部循环内部，使用一个内部循环，从当前元素的下一个位置开始遍历数组中的其他元素，假设当前元素为nums[j]。
（5）在内部循环中，判断nums[i]和nums[j]的和是否等于目标和k。
-
如果相等，表示找到了一对元素的和为k，输出"yes"，并结束程序。
-
如果不相等，则继续内部循环，遍历下一个元素。
（6）如果遍历完所有元素后仍未找到满足条件的元素对，输出"no"。
这个算法的时间复杂度为O(n^2)，其中n为序列的长度。由于题目给出的时间限制为1000，这个算法在输入规模不超过1000时可以在给定时间内解决问题。
下面是一个使用C语言编写的解决方案：
#include <stdio.h>
int main() {
int n, k;
scanf("%d %d", &n, &k);
int nums[1000];
for (int i = 0; i < n; i++) {
scanf("%d", &nums[i]);
}
int found = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (nums[i] + nums[j] == k) {
found = 1;
break;
}
}
if (found) {
break;
}
}
if (found) {
printf("yes\n");
} else {
printf("no\n");
}
return 0;
}
这段代码首先读取输入的序列长度n和目标和k，然后读取n个整数到数组nums中。接下来，使用嵌套的for循环遍历所有可能的元素对，判断它们的和是否为k。如果找到一对和为k的元素，将found标记为1，并跳出循环。最后，根据found的值输出结果。
请注意，根据题目的要求，序列长度n不会超过1000，因此我们在代码中定义了一个长度为1000的数组nums来存储输入的整数序列。
第2题：Minecraft
Minecraft是一个几乎无所不能的沙盒游戏，玩家可以利用游戏内的各种资源进行创造，搭建自己的世界。
在Minecraft中，基本的建筑元素是边长为1个单位的立方体，Tony想用N个这种小立方体搭建一个长方体，并用他珍藏已久的贴纸对其进行装饰。如果一张贴纸可以贴满小立方体的一个面。那么，他需要用掉多少张贴纸呢?
时间限制：1000
内存限制：65536
输入
一个整数N，表示小明所拥有的小立方体的个数。N不会超过1000。
输出
一个整数，即小明最少用掉的贴纸有多少张。
样例输入
9
样例输出
30
这个问题可以通过计算来解决。我们知道一个长方体有6个面，每个面都需要用贴纸覆盖。而每个面都由多个小立方体组成，每个小立方体需要用一张贴纸覆盖。
以下是解题的基本思路：
（1）读取输入的小立方体的个数N。
（2）计算需要覆盖的面的总数，即6个面的总和。
（3）将需要覆盖的面的总数乘以N，得到所需的贴纸数量。
（4）输出所需的贴纸数量。
以下是使用C语言编写的解决方案：
#include <stdio.h>
int main() {
int N;
scanf("%d", &N);
int total_faces = 6; // 一个长方体有6个面
int stickers = total_faces * N;
printf("%d\n", stickers);
return 0;
}
这段代码首先读取输入的小立方体的个数N。然后，计算需要覆盖的面的总数，即6个面的总和。最后，将需要覆盖的面的总数乘以N，得到所需的贴纸数量。最后，输出所需的贴纸数量。
根据题目的要求，小立方体的个数N不会超过1000，因此我们可以直接在计算过程中处理较大的数值。
第3题：踩方格
有一个方格矩阵，矩阵边界在无穷远处。我们做如下假设：
a. 每走一步时，只能从当前方格移动一格，走到某个相邻的方格上;
b. 走过的格子立即塌陷无法再走第二次;
c. 只能向北、东、西三个方向走;
请问：如果允许在方格矩阵上走n步，共有多少种不同的方案。2种走法只要有一步不一样，即被认为是不同的方案。
时间限制：1000
内存限制：65536
输入
允许在方格上行走的步数n(n <= 20)
输出
计算出的方案数量
样例输入
2
样例输出
7
这个问题可以使用递归的方式来解决。每一步可以选择向北、东、西三个方向中的一个方向前进，然后在下一步中继续做出相同的选择，直到步数达到限制或无法再继续移动为止。
以下是解题的基本思路：
（1）读取输入的允许在方格上行走的步数n。
（2）定义一个递归函数countPaths，接受两个参数：当前位置的坐标(x, y)和剩余步数remainingSteps。
（3）在递归函数中，首先判断剩余步数是否为0，如果是则返回1，表示找到一种方案。
（4）否则，定义一个变量count初始值为0，用于记录方案数量。
（5）在递归函数中，分别递归调用countPaths函数，传入向北、东、西三个方向移动一步后的新坐标和剩余步数减1，将返回的结果累加到count中。
（6）最后，返回count作为当前位置和剩余步数的方案数量。
（7）在主函数中，调用countPaths函数，传入初始位置(0, 0)和允许的步数n，将返回的方案数量输出。
以下是使用C语言编写的解决方案：
#include <stdio.h>
int countPaths(int x, int y, int remainingSteps) {
if (remainingSteps == 0) {
return 1;
}
int count = 0;
count += countPaths(x, y + 1, remainingSteps - 1); // 向北移动一步
count += countPaths(x + 1, y, remainingSteps - 1); // 向东移动一步
count += countPaths(x - 1, y, remainingSteps - 1); // 向西移动一步
return count;
}
int main() {
int n;
scanf("%d", &n);
int totalPaths = countPaths(0, 0, n);
printf("%d\n", totalPaths);
return 0;
}
这段代码首先读取输入的允许在方格上行走的步数n。然后，定义了一个递归函数countPaths来计算方案数量。在递归函数中，首先判断剩余步数是否为0，如果是则返回1，表示找到一种方案。否则，定义一个变量count用于记录方案数量，并分别递归调用countPaths函数，传入向北、东、西三个方向移动一步后的新坐标和剩余步数减1，将返回的结果累加到count中。最后，返回count作为当前位置和剩余步数的方案数量。
在主函数中，调用countPaths函数，传入初始位置(0, 0)和允许的步数n，将返回的方案数量输出。
根据题目的要求，允许在方格上行走的步数n不会超过20，因此递归的深度不会过大，可以在给定时间内解决问题。
第4题：苹果消消乐
有100个苹果和香蕉排成一条直线，其中有N个香蕉，你可以使用至多M次魔法道具将香蕉变成苹果，最后“最长的连续苹果数量”即为你本次苹果消消乐的得分，给定苹果和香蕉的排列，求你能获得的最大得分。
时间限制：1000
内存限制：65536
输入
第一行是一个整数T(1 <= T <= 10)，代表测试数据的组数。 每个测试数据第一行是2个整数N和M(0 <= N, M <= 100)。第二行包含N个整数a1, a2, … aN(1 <= a1 < a2 < … < aN <= 100)，表示第a1, a2, … aN个位置上摆放的是香蕉。
输出
对于每组数据，输出通过使用魔法道具后你能获得的最大得分。
样例输入
3
5 1
34 77 82 83 84
5 2
10 30 55 56 90
5 10
10 30 55 56 90
样例输出
76
59
100
提示
这是个枚举题
这个问题可以通过枚举的方式来解决。我们可以遍历每个位置，将其作为连续苹果的起始位置，然后向后遍历苹果和香蕉的排列，同时记录使用魔法道具的次数。在遍历过程中，如果遇到香蕉，且还有剩余的魔法道具可用，则将香蕉变成苹果，并增加得分。最后，找到最大的得分即可。
以下是解题的基本思路：
（1）读取输入的测试数据组数T。
（2）对于每组测试数据，读取香蕉和苹果的个数N和M。
（3）读取N个整数，表示香蕉的位置。
（4）初始化最大得分maxScore为0。
（5）遍历每个位置i作为连续苹果的起始位置：
-
初始化当前得分score为0。
-
初始化剩余魔法道具次数remainingMagic为M。
-
遍历位置j从i到100：
-
如果j是香蕉的位置且remainingMagic大于0，则将香蕉变成苹果，增加得分score，并减少剩余魔法道具次数remainingMagic。
-
否则，增加得分score。
-
如果得分score大于最大得分maxScore，则更新最大得分maxScore。
-
（6）输出最大得分maxScore。
以下是使用C语言编写的解决方案：
#include <stdio.h>
int main() {
int T;
scanf("%d", &T);
while (T--) {
int N, M;
scanf("%d %d", &N, &M);
int bananas[N];
for (int i = 0; i < N; i++) {
scanf("%d", &bananas[i]);
}
int maxScore = 0;
for (int i = 0; i < 100; i++) {
int score = 0;
int remainingMagic = M;
for (int j = i; j < 100; j++) {
if (remainingMagic > 0 && j == bananas[score]) {
remainingMagic--;
score++;
} else {
score++;
}
if (score > maxScore) {
maxScore = score;
}
}
}
printf("%d\n", maxScore);
}
return 0;
}
这段代码首先读取输入的测试数据组数T。然后，对于每组测试数据，读取香蕉和苹果的个数N和M，以及N个整数表示香蕉的位置。接下来，初始化最大得分maxScore为0，并进行枚举遍历。在遍历过程中，对于每个位置i作为连续苹果的起始位置，初始化当前得分score为0和剩余魔法道具次数remainingMagic为M。然后，遍历位置j从i到100，根据香蕉的位置和剩余魔法道具次数更新得分score，并更新最大得分maxScore。最后，输出最大得分maxScore。
根据题目的要求，测试数据组数T不会超过10，枚举的范围在100内，因此可以在给定时间内解决问题。
第5题：流感传染
有一批易感人群住在网格状的宿舍区内，宿舍区为n*n的矩阵，每个格点为一个房间，房间里可能住人，也可能空着。在第一天，有些房间里的人得了流感，以后每天，得流感的人会使其邻居传染上流感，(已经得病的不变)，空房间不会传染。请输出第m天得流感的人数。
时间限制：1000
内存限制：65536
输入
第一行一个数字n，n不超过100，表示有n*n的宿舍房间。 接下来的n行，每行n个字符，’.’表示第一天该房间住着健康的人，’#’表示该房间空着，’@’表示第一天该房间住着得流感的人。 接下来的一行是一个整数m，m不超过100.
输出
输出第m天，得流感的人数
样例输入
5
…#
.#.@.
.#@…
#…
…
4
样例输出
16
这个问题可以使用广度优先搜索（BFS）来解决。我们可以将所有初始感染的人作为起始节点，然后以它们为中心向外扩散，每次将感染传播到相邻的健康人，直到达到指定的天数。
以下是解题的基本思路：
（1）读取输入的宿舍房间大小n。
（2）创建一个n*n的二维字符数组rooms来表示宿舍房间的状态。
（3）读取n行字符，将它们存储到rooms数组中。
（4）读取指定的天数m。
（5）创建一个队列，用于存储当前感染的人的坐标。
（6）遍历rooms数组，将初始感染的人的坐标加入队列。
（7）创建一个整数变量infectedCount，并将其初始值设置为队列的长度，表示初始感染的人数。
（8）创建一个整数变量days，并将其初始值设置为1，表示第一天。
（9）使用BFS算法进行传播：
-
创建一个整数变量nextInfectedCount，用于记录下一天感染的人数。
-
在循环中，从队列中取出一个感染的人的坐标。
-
遍历该人的相邻人，如果相邻的人是健康的，则将其感染，并将其坐标加入队列。
-
每次遍历一个感染的人的相邻人后，将nextInfectedCount增加相应的数量。
-
如果队列不为空，则表示还有感染的人未传播完，将days增加1，更新infectedCount为nextInfectedCount。
-
如果队列为空，则表示感染已经传播完，退出循环。
（10）如果指定的天数m大于等于第一天，则根据m和第一天的差值，使用BFS算法继续传播，直到达到指定的天数。
（11）输出最后一天感染的人数infectedCount。
以下是使用C语言编写的解决方案：
#include <stdio.h>
#define MAX_N 100
typedef struct {
int x;
int y;
} Coordinate;
int main() {
int n;
scanf("%d", &n);
char rooms[MAX_N][MAX_N];
for (int i = 0; i < n; i++) {
scanf("%s", rooms[i]);
}
int m;
scanf("%d", &m);
int dx[] = {
-1, 0, 1, 0};
int dy[] = {
0, 1, 0, -1};
Coordinate queue[MAX_N * MAX_N];
int front = 0;
int rear = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (rooms[i][j] == '@') {
Coordinate coord = {
i, j};
queue[rear++] = coord;
}
}
}
int infectedCount = rear;
int days = 1;
while (days < m) {
int nextInfectedCount = 0;
while (front < rear) {
Coordinate current = queue[front++];
for (int k = 0; k < 4; k++) {
int nx = current.x + dx[k];
int ny = current.y + dy[k];
if (nx >= 0 && nx < n && ny >= 0 && ny < n && rooms[nx][ny] == '.') {
rooms[nx][ny] = '@';
Coordinate newCoord = {
nx, ny};
queue[rear++] = newCoord;
nextInfectedCount++;
}
}
}
if (front == rear) {
break;
}
days++;
infectedCount += nextInfectedCount;
}
printf("%d\n", infectedCount);
return 0;
}
这段代码首先读取输入的宿舍房间大小n，并创建一个n*n的二维字符数组rooms来表示宿舍房间的状态。然后，通过循环读取n行这个问题可以通过广度优先搜索（BFS）来解决。我们可以将感染的人作为起始点，然后以他们为中心向外扩散，每次将感染传播到相邻的健康人，直到达到指定的天数。