2021年03月 C/C++（三级）真题解析#中国电子学会#全国青少年软件编程等级考试

第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 

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 

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 

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 

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 

#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）来解决。我们可以将感染的人作为起始点，然后以他们为中心向外扩散，每次将感染传播到相邻的健康人，直到达到指定的天数。