第1题：红与黑
有一间长方形的房子，地上铺了红色、黑色两种颜色的正方形瓷砖。你站在其中一块黑色的瓷砖上，只能向相邻的黑色瓷砖移动。请写一个程序，计算你总共能够到达多少块黑色的瓷砖。
时间限制：1000
内存限制：65536
输入包括多个数据集合。每个数据集合的第一行是两个整数W和H，分别表示x方向和y方向瓷砖的数量。W和H都不超过20。在接下来的H行中，每行包括W个字符。每个字符表示一块瓷砖的颜色，规则如下 1）'.'：黑色的瓷砖； 2）'#'：白色的瓷砖； 3）'@'：黑色的瓷砖，并且你站在这块瓷砖上。该字符在每个数据集合中唯一出现一次。 当在一行中读入的是两个零时，表示输入结束。
输出对每个数据集合，分别输出一行，显示你从初始位置出发能到达的瓷砖数(记数时包括初始位置的瓷砖)。
样例输入6 9
...#.
...#
...
...
...
...
...
#@...#
.#...#.
0 0
样例输出45
以下是一个使用深度优先搜索算法（DFS）解决该问题的示例C语言程序：
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语言实现的示例程序：
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语言实现的示例程序：
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语言实现的示例程序：
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 函数计算表达式树的值，并输出结果。
请注意，该程序假设输入的中缀表达式合法且符合要求。在实际应用中，你可能需要添加一些错误处理代码来处理无效的输入情况。