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

第1题：红与黑

有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。你站在其中一块黑色的瓷砖上，只能向相邻的黑色瓷砖移动。请写一个程序，计算你总共能够到达多少块黑色的瓷砖。
时间限制：1000
内存限制：65536
输入
包括多个数据集合。每个数据集合的第一行是两个整数W和H，分别表示x方向和y方向瓷砖的数量。W和H都不超过20。在接下来的H行中，每行包括W个字符。每个字符表示一块瓷砖的颜色，规则如下 1）‘.’：黑色的瓷砖； 2）‘#’：白色的瓷砖； 3）‘@’：黑色的瓷砖，并且你站在这块瓷砖上。该字符在每个数据集合中唯一出现一次。 当在一行中读入的是两个零时，表示输入结束。
输出
对每个数据集合，分别输出一行，显示你从初始位置出发能到达的瓷砖数(记数时包括初始位置的瓷砖)。
样例输入
6 9
…#.
…#
…
…
…
…
…
#@…#
.#…#.
0 0
样例输出
45

以下是一个使用深度优先搜索算法（DFS）解决该问题的示例C语言程序：

#include <stdio.h>#define MAX_SIZE 20int W, H;
char tiles[MAX_SIZE][MAX_SIZE];
int visited[MAX_SIZE][MAX_SIZE];int dfs(int x, int y) {if (x < 0 || x >= W || y < 0 || y >= H || tiles[y][x] != '.' || visited[y][x])return 0;visited[y][x] = 1;int count = 1;count += dfs(x - 1, y); // 左count += dfs(x + 1, y); // 右count += dfs(x, y - 1); // 上count += dfs(x, y + 1); // 下return count;
}int main() {while (1) {scanf("%d %d", &W, &H);if (W == 0 && H == 0)break;int start_x, start_y;for (int i = 0; i < H; i++) {scanf("%s", tiles[i]);for (int j = 0; j < W; j++) {if (tiles[i][j] == '@') {start_x = j;start_y = i;}}}// 初始化visited数组for (int i = 0; i < H; i++) {for (int j = 0; j < W; j++) {visited[i][j] = 0;}}int result = dfs(start_x, start_y);printf("%d\n", result);}return 0;
}

该程序首先读取输入的W和H，然后读取瓷砖颜色信息，并找到你所站立的黑色瓷砖的位置。接下来，使用深度优先搜索算法从起始位置开始遍历与之相邻的黑色瓷砖，并标记已访问过的瓷砖。最后，统计访问过的瓷砖数量并输出结果。

注意：该程序假设输入是正确的，即输入的瓷砖数量不超过20，且起始位置字符’@'在每个数据集合中唯一出现一次。在实际应用中，你可能需要添加一些错误处理代码来处理无效的输入情况。

第2题：重建二叉树

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

为了解决该问题，我们可以使用递归的方法来重建二叉树，并输出后序遍历结果。下面是一个使用C语言实现的示例程序：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>typedef struct TreeNode {char val;struct TreeNode* left;struct TreeNode* right;
} TreeNode;TreeNode* buildTree(char* preorder, char* inorder, int preStart, int preEnd, int inStart, int inEnd) {if (preStart > preEnd || inStart > inEnd)return NULL;// 创建根节点TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));root->val = preorder[preStart];root->left = NULL;root->right = NULL;// 在中序遍历中找到根节点的索引int rootIndex;for (int i = inStart; i <= inEnd; i++) {if (inorder[i] == root->val) {rootIndex = i;break;}}int leftSubtreeSize = rootIndex - inStart;// 递归构建左子树和右子树root->left = buildTree(preorder, inorder, preStart + 1, preStart + leftSubtreeSize, inStart, rootIndex - 1);root->right = buildTree(preorder, inorder, preStart + leftSubtreeSize + 1, preEnd, rootIndex + 1, inEnd);return root;
}void postorderTraversal(TreeNode* root) {if (root == NULL)return;// 后序遍历：左子树 -> 右子树 -> 根节点postorderTraversal(root->left);postorderTraversal(root->right);printf("%c", root->val);
}int main() {char preorder[100];char inorder[100];while (scanf("%s %s", preorder, inorder) != EOF) {int n = strlen(preorder);TreeNode* root = buildTree(preorder, inorder, 0, n - 1, 0, n - 1);postorderTraversal(root);printf("\n");}return 0;
}

该程序首先定义了一个树节点的结构体 TreeNode，其中包含节点的值 val，以及左子树和右子树的指针。然后，使用递归的方式实现了 buildTree 函数，该函数根据前序遍历和中序遍历的结果构建二叉树。最后，使用递归的方式实现了 postorderTraversal 函数，用于后序遍历输出结果。

在 main 函数中，程序通过循环读取输入的前序遍历和中序遍历字符串，并调用 buildTree 构建二叉树，然后调用 postorderTraversal 函数输出后序遍历结果。

请注意，该程序假设输入的前序遍历和中序遍历结果是合法的，且每个字符在遍历结果中都是唯一的。在实际应用中，你可能需要添加一些错误处理代码来处理无效的输入情况。

第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 <stdio.h>
#include <stdlib.h>typedef struct Pig {int weight;struct Pig* next;
} Pig;Pig* top = NULL;void push(int weight) {Pig* newPig = (Pig*)malloc(sizeof(Pig));newPig->weight = weight;newPig->next = top;top = newPig;
}void pop() {if (top == NULL)return;Pig* temp = top;top = top->next;free(temp);
}int min() {if (top == NULL)return -1;int minWeight = top->weight;Pig* current = top->next;while (current != NULL) {if (current->weight < minWeight)minWeight = current->weight;current = current->next;}return minWeight;
}int main() {char operation[10];int weight;while (scanf("%s", operation) != EOF) {if (strcmp(operation, "push") == 0) {scanf("%d", &weight);push(weight);} else if (strcmp(operation, "pop") == 0) {pop();} else if (strcmp(operation, "min") == 0) {int minWeight = min();if (minWeight != -1)printf("%d\n", minWeight);}}return 0;
}

该程序定义了一个猪的结构体 Pig，其中包含猪的重量 weight 和指向堆顶下一头猪的指针 next。然后，使用链表来实现堆数据结构，使用 top 指针来指示堆顶的猪。

程序实现了 push 函数用于将一头新猪叠放在堆顶， pop 函数用于将堆顶的猪赶走， min 函数用于查询猪堆里最轻的猪的重量。

在 main 函数中，程序通过循环读取输入的操作和猪的重量，并调用相应的函数来执行操作和查询最轻猪的重量。

请注意，该程序假设输入的操作合法且符合要求。在实际应用中，你可能需要添加一些错误处理代码来处理无效的输入情况。

第4题：表达式·表达式树·表达式求值

众所周知，任何一个表达式，都可以用一棵表达式树来表示。例如，表达式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
3
a 2
b 7
c 5
样例输出
abc*+
+
/ \
a *
/ \
b c
37

为了解决这个问题，我们可以使用递归的方式构建表达式树，并且同时输出逆波兰表达式。下面是一个使用C语言实现的示例程序：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>typedef struct Node {char data;struct Node* left;struct Node* right;
} Node;Node* createNode(char data) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->left = NULL;newNode->right = NULL;return newNode;
}int isOperator(char c) {if (c == '+' || c == '-' || c == '*' || c == '/')return 1;return 0;
}int isOperand(char c) {if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))return 1;return 0;
}void buildExpressionTree(char* infix, int n, char** variables, int* values, Node** root) {int i;Node* stack[n];int top = -1;for (i = 0; i < strlen(infix); i++) {if (isOperand(infix[i])) {int j;char variable = infix[i];int value = 0;for (j = 0; j < n; j++) {if (variables[j][0] == variable) {value = values[j];break;}}Node* operandNode = createNode(variable);stack[++top] = operandNode;} else if (isOperator(infix[i])) {Node* operatorNode = createNode(infix[i]);operatorNode->right = stack[top--];operatorNode->left = stack[top--];stack[++top] = operatorNode;}}*root = stack[top--];
}void postOrderTraversal(Node* root) {if (root != NULL) {postOrderTraversal(root->left);postOrderTraversal(root->right);printf("%c", root->data);}
}int evaluateExpressionTree(Node* root) {if (root != NULL) {if (isOperand(root->data)) {return root->data - 'a' + 1;} else {int leftValue = evaluateExpressionTree(root->left);int rightValue = evaluateExpressionTree(root->right);switch (root->data) {case '+':return leftValue + rightValue;case '-':return leftValue - rightValue;case '*':return leftValue * rightValue;case '/':return leftValue / rightValue;}}}return 0;
}void printExpressionTree(Node* root, int level) {int i;if (root == NULL)return;printExpressionTree(root->right, level + 1);for (i = 0; i < level - 1; i++)printf(" ");if (level > 0)printf("/");printf("%c\n", root->data);printExpressionTree(root->left, level + 1);
}int main() {char infix[51];int n;int i;scanf("%s", infix);scanf("%d", &n);char* variables[n];int values[n];for (i = 0; i < n; i++) {variables[i] = (char*)malloc(2 * sizeof(char));scanf("%s %d", variables[i], &values[i]);}Node* root = NULL;buildExpressionTree(infix, n, variables, values, &root);postOrderTraversal(root);printf("\n");printExpressionTree(root, 0);int result = evaluateExpressionTree(root);printf("%d\n", result);return 0;
}

程序中定义了一个表示表达式树的结构体 Node，其中包含数据 data 和指向左子树和右子树的指针 left 和 right。函数 createNode 用于创建一个新的节点。

程序中使用栈来构建表达式树。在 buildExpressionTree 函数中，我们遍历中缀表达式的每个字符，如果遇到操作数，则创建一个叶子节点，并将其压入栈中；如果遇到操作符，则创建一个新节点，并将栈顶的两个节点分别设置为新节点的左右子树，然后将新节点压入栈中。最后，栈顶即为整个表达式树的根节点。

在 postOrderTraversal 函数中，我们使用后根遍历输出逆波兰表达式。

在 evaluateExpressionTree 函数中，我们使用递归的方式计算表达式树的值。如果节点是操作数，则返回变量对应的值；如果节点是操作符，则递归计算左子树和右子树的值，并根据操作符进行相应的运算。

在 printExpressionTree 函数中，我们使用递归的方式打印表达式树的显示。通过先打印右子树、根节点、再打印左子树的顺序，可以得到正确的显示结果。

在 main 函数中，我们读取输入的中缀表达式、变量数量和变量值，并调用 buildExpressionTree 函数构建表达式树。然后，分别调用 postOrderTraversal 函数输出逆波兰表达式、printExpressionTree 函数输出表达式树的显示，并调用 evaluateExpressionTree 函数计算表达式树的值，并输出结果。

请注意，该程序假设输入的中缀表达式合法且符合要求。在实际应用中，你可能需要添加一些错误处理代码来处理无效的输入情况。