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 20

int 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 函数计算表达式树的值，并输出结果。

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