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

C/C++编程（1~8级）全部真题・点这里

第1题：有多少种二叉树

输入n(1 时间限制：1000
内存限制：65536
输入
整数n
输出
答案
样例输入
3
样例输出
5

这个问题可以使用动态规划的方法来解决。我们可以定义一个数组dp，其中dp[i]表示有i个节点时的二叉树的种数。根据二叉树的性质，我们可以知道一个二叉树的种数取决于其左子树和右子树的种数。

具体的动态规划递推关系如下：

对于i个节点的二叉树，我们可以选择一个节点作为根节点，将其左边的节点构成左子树，右边的节点构成右子树。根据这个划分，可以得到以下关系：

dp[i] = dp[0] * dp[i-1] + dp[1] * dp[i-2] + ... + dp[i-1] * dp[0]

其中，dp[j]表示有j个节点构成的二叉树的种数。

根据上述递推关系，我们可以通过动态规划的方式计算出dp[n]，即有n个节点的二叉树的种数。

下面是使用C语言实现的代码：

#include 

long long int countBinaryTrees(int n) {
    long long int dp[n + 1];
    dp[0] = 1;
    dp[1] = 1;

    for (int i = 2; i <= n; i++) {
        dp[i] = 0;
        for (int j = 0; j < i; j++) {
            dp[i] += dp[j] * dp[i - j - 1];
        }
    }

    return dp[n];
}

int main() {
    int n;
    scanf("%d", &n);

    long long int result = countBinaryTrees(n);
    printf("%lld\n", result);

    return 0;
}

该代码中使用了一个数组dp来保存中间结果，避免重复计算。时间复杂度为O(n^2)，空间复杂度为O(n)。请注意，由于给定的n的范围较小，因此使用整型变量和long long int类型即可满足要求。如果需要支持更大范围的n，可以考虑使用高精度整数库。

第2题：城堡问题

1 2 3 4 5 6 7
#############################
1 # | # | # | | #
#####—#####—#—#####—#
2 # # | # # # # #
#—#####—#####—#####—#
3 # | | # # # # #
#—#########—#####—#—#
4 # # | | | | # #
#############################
(图 1)
# = Wall
| = No wall
- = No wall
图1是一个城堡的地形图。请你编写一个程序，计算城堡一共有多少房间，最大的房间有多大。城堡被分割成m×n(m≤50，n≤50)个方块，每个方块可以有0~4面墙。
时间限制：1000
内存限制：65536
输入
程序从标准输入设备读入数据。第1、2行每行1个整数，分别是南北向、东西向的方块数。在接下来的输入行里，每个方块用一个数字(0≤p≤50)描述。用一个数字表示方块周围的墙，1表示西墙，2表示北墙，4表示东墙，8表示南墙。每个方块用代表其周围墙的数字之和表示。城堡的内墙被计算两次，方块(1,1)的南墙同时也是方块(2,1)的北墙。输入的数据保证城堡至少有两个房间。
输出
输出2行，每行一个数，表示城堡的房间数、城堡中最大房间所包括的方块数。结果显示在标准输出设备上。
样例输入
4
7
11 6 11 6 3 10 6
7 9 6 13 5 15 5
1 10 12 7 13 7 5
13 11 10 8 10 12 13
样例输出
5
9

这个问题可以使用深度优先搜索（DFS）算法来解决。我们可以遍历城堡的每个房间，对于每个未访问过的房间，进行深度优先搜索，统计房间的数量和最大房间的大小。

具体的算法步骤如下：

1. 定义一个二维数组visited用于记录房间的访问状态，初始化为0。

2. 定义变量roomCount用于记录房间数量，初始化为0。

3. 定义变量maxRoomSize用于记录最大房间的大小，初始化为0。

4. 对于城堡的每个房间，如果该房间未被访问过，则进行深度优先搜索：

• 将当前房间标记为已访问（设置visited数组对应位置为1）。

• 增加roomCount的值。

• 计算当前房间的大小，即从当前房间开始的连通区域的大小，使用递归实现：

  • 统计当前房间的大小，并更新maxRoomSize的值。

  • 对当前房间的四个方向进行判断，如果该方向没有墙且相邻房间未被访问过，则继续递归搜索该相邻房间。

5. 输出roomCount和maxRoomSize的值。

下面是使用C语言实现的代码：

#include 

#define MAX_SIZE 50

int castle[MAX_SIZE][MAX_SIZE];
int visited[MAX_SIZE][MAX_SIZE];

int dfs(int row, int col) {
    if (visited[row][col])
        return 0;
    
    visited[row][col] = 1;
    int size = 1;
    
    if (castle[row][col] % 2 == 0)  // 没有西墙
        size += dfs(row, col - 1);
    if (castle[row][col] % 4 >= 2)  // 没有北墙
        size += dfs(row - 1, col);
    if (castle[row][col] % 8 >= 4)  // 没有东墙
        size += dfs(row, col + 1);
    if (castle[row][col] >= 8)      // 没有南墙
        size += dfs(row + 1, col);
    
    return size;
}

void findLargestRoom(int m, int n, int* roomCount, int* maxRoomSize) {
    *roomCount = 0;
    *maxRoomSize = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            visited[i][j] = 0;
        }
    }
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (!visited[i][j]) {
                (*roomCount)++;
                int size = dfs(i, j);
                if (size > *maxRoomSize)
                    *maxRoomSize = size;
            }
        }
    }
}

int main() {
    int m, n;
    scanf("%d%d", &m, &n);
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &castle[i][j]);
        }
    }
    
    int roomCount, maxRoomSize;
    findLargestRoom(m, n, &roomCount, &maxRoomSize);
    printf("%d\n%d\n", roomCount, maxRoomSize);
    
    return 0;
}

该代码中，castle数组表示城堡的地形图，visited数组用于记录房间的访问状态。dfs函数实现了深度优先搜索，计算从某个房间开始的连通区域的大小。findLargestRoom函数遍历城堡的每个房间，对于每个未访问过的房间进行深度优先搜索，统计房间的数量和最大房间的大小。最后，输出房间数量和最大房间的大小。

该代码的时间复杂度为O(mn)，其中m和n分别是城堡的南北向和东西向方块数。空间复杂度为O(mn)，用于存储visited数组。请注意，题目给定的城堡大小范围较小，因此使用二维数组存储数据是可行的。如果需要支持更大范围的城堡，可以考虑使用动态分配的二维数组或其他数据结构来存储数据。

第3题：快速堆猪

小明有很多猪，他喜欢玩叠猪游戏，就是将猪一头头叠起来。猪叠上去后，还可以把顶上的猪拿下来。小明知道每头猪的重量，而且他还随时想知道叠在那里的猪最轻的是多少斤。
时间限制：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
样例输出
2
2

以下是使用C语言编写的解决方案：

#include 
#include 

typedef struct {
    int weight;
    struct Node* next;
} Node;

Node* stack = NULL;
int minWeight = -1;

void push(int weight) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->weight = weight;
    newNode->next = stack;
    stack = newNode;

    if (minWeight == -1 || weight < minWeight) {
        minWeight = weight;
    }
}

void pop() {
    if (stack == NULL) {
        return;
    }

    Node* top = stack;
    stack = stack->next;
    free(top);

    if (stack == NULL) {
        minWeight = -1;
    }
}

int getMinWeight() {
    return minWeight;
}

int main() {
    char command[10];
    int weight;

    while (scanf("%s", command) != EOF) {
        if (strcmp(command, "push") == 0) {
            scanf("%d", &weight);
            push(weight);
        } else if (strcmp(command, "pop") == 0) {
            pop();
        } else if (strcmp(command, "min") == 0) {
            int min = getMinWeight();
            if (min != -1) {
                printf("%d\n", min);
            }
        }
    }

    return 0;
}

这段代码使用堆栈（stack）数据结构来实现叠猪游戏。每个猪的重量被存储在一个链表节点（Node）中，而链表的头部代表猪堆的顶部。初始时，堆栈为空，最轻的猪的重量为-1。

程序逐行读取输入，根据命令执行相应的操作。当输入是"push n"时，程序将创建一个新的节点，并将其压入堆栈。如果新节点的重量小于当前最轻的猪的重量（或堆栈为空），则更新最轻猪的重量。当输入是"pop"时，程序将从堆栈中弹出一个节点（如果堆栈不为空）。如果堆栈为空，最轻猪的重量将被重置为-1。当输入是"min"时，程序将输出当前最轻的猪的重量（如果堆栈不为空）。

请注意，此代码假定输入是有效的，并且不会超出内存限制。你可以根据需要对其进行修改和扩展。

第4题：重建二叉树

给定一棵二叉树的前序遍历和中序遍历的结果，求其后序遍历。
时间限制：1000
内存限制：65536
输入
输入可能有多组，以EOF结束。 每组输入包含两个字符串，分别为树的前序遍历和中序遍历。每个字符串中只包含大写字母且互不重复。
输出
对于每组输入，用一行来输出它后序遍历结果。
样例输入
DBACEGF ABCDEFG
BCAD CBAD
样例输出
ACBFGED
CDAB

以下是使用C语言编写的解决方案：

#include 
#include 
#include 

typedef struct Node {
    char value;
    struct Node* left;
    struct Node* right;
} Node;

Node* buildTree(char* preorder, char* inorder, int preStart, int preEnd, int inStart, int inEnd) {
    if (preStart > preEnd || inStart > inEnd) {
        return NULL;
    }

    char rootValue = preorder[preStart];
    int rootIndex = 0;
    for (int i = inStart; i <= inEnd; i++) {
        if (inorder[i] == rootValue) {
            rootIndex = i;
            break;
        }
    }

    int leftSize = rootIndex - inStart;
    Node* root = (Node*)malloc(sizeof(Node));
    root->value = rootValue;
    root->left = buildTree(preorder, inorder, preStart + 1, preStart + leftSize, inStart, rootIndex - 1);
    root->right = buildTree(preorder, inorder, preStart + leftSize + 1, preEnd, rootIndex + 1, inEnd);

    return root;
}

void postorderTraversal(Node* root) {
    if (root == NULL) {
        return;
    }

    postorderTraversal(root->left);
    postorderTraversal(root->right);
    printf("%c", root->value);
}

int main() {
    char preorder[100];
    char inorder[100];

    while (scanf("%s %s", preorder, inorder) != EOF) {
        int preLength = strlen(preorder);
        int inLength = strlen(inorder);

        Node* root = buildTree(preorder, inorder, 0, preLength - 1, 0, inLength - 1);

        postorderTraversal(root);
        printf("\n");

        free(root);
    }

    return 0;
}

这段代码实现了根据前序遍历和中序遍历结果重建二叉树，并输出后序遍历结果。

程序逐行读取输入的前序遍历和中序遍历结果，并调用buildTree函数构建二叉树。buildTree函数根据当前的前序遍历序列、中序遍历序列以及其在序列中的起始和结束位置进行递归构建。在每次递归中，找到当前根节点的值，然后通过在中序遍历序列中找到根节点的位置，将序列分为左子树和右子树。然后，递归地构建左子树和右子树，并将它们连接到当前根节点上。

构建完二叉树后，调用postorderTraversal函数进行后序遍历，并输出结果。postorderTraversal函数使用递归方式进行后序遍历，先遍历左子树，再遍历右子树，最后输出当前节点的值。

请注意，此代码假定输入是有效的，并且不会超出内存限制。你可以根据需要对其进行修改和扩展。