1151 LCA in a Binary Tree (30 point(s))

题目描述

The lowest common ancestor (LCA) of two nodes U and V in a tree is the deepest node that has both U and V as descendants.

Given any two nodes in a binary tree, you are supposed to find their LCA.

Input Specification:

Each input file contains one test case. For each case, the first line gives two positive integers: M (≤ 1,000), the number of pairs of nodes to be tested; and N (≤ 10,000), the number of keys in the binary tree, respectively. In each of the following two lines, N distinct integers are given as the inorder and preorder traversal sequences of the binary tree, respectively. It is guaranteed that the binary tree can be uniquely determined by the input sequences. Then M lines follow, each contains a pair of integer keys U and V. All the keys are in the range of int.

Output Specification:

For each given pair of U and V, print in a line LCA of U and V is A. if the LCA is found and A is the key. But if A is one of U and V, print X is an ancestor of Y. where X is A and Y is the other node. If U or V is not found in the binary tree, print in a line ERROR: U is not found. or ERROR: V is not found. or ERROR: U and V are not found.

Sample Input:

6 8
7 2 3 4 6 5 1 8
5 3 7 2 6 4 8 1
2 6
8 1
7 9
12 -3
0 8
99 99

Sample Output:

LCA of 2 and 6 is 3.
8 is an ancestor of 1.
ERROR: 9 is not found.
ERROR: 12 and -3 are not found.
ERROR: 0 is not found.
ERROR: 99 and 99 are not found.

思路

这道题主要分为两步执行，1.构建树 2.寻找最小公共祖先节点

• 构建儿叉树
  这里主要考察先序遍历以及中序遍历来构建二叉树，这种构建方法在PAT中非常常见，是需要记住的。
• 寻找最小公共祖先节点。具体见代码注释。

#include <set>
#include <map>
#include <iostream>
#include <vector>
using namespace std;
int n, m;
int v1, v2;
vector<int> inorder;//中序
vector<int> preorder;//先序
map<int, bool> flags;
struct tree_node//树节点的结构体
{
	int val;
	tree_node* left;
	tree_node* right;
};
tree_node* build_tree(int in_l, int in_r, int pre_l, int pre_r) {
//以上函数的参数分别代表中序左边序号，中序右边序号，先序左边序号，先序右边序号
	if (pre_l > pre_r) return NULL;
	int root = preorder[pre_l];//先序序列的最左边节点就是他的根节点
	int root_index;
	for (int i = in_l; i <= in_r; i++) {//寻找到中序序列中的根节点的位置
		if (inorder[i] == root) {
			root_index = i;
			break;
		}
	}
	int length = root_index - in_l;// 计算出左子树的个数
	tree_node* node = new tree_node;
	node->val = root;
	node->left = build_tree(in_l, root_index - 1, pre_l + 1, pre_l + length);//计算出左子树在先序序列和中序序列中的边界位置。
	node->right = build_tree(root_index + 1, in_r, pre_l + length + 1, pre_r);
	return node;
}
// 查找最小公共祖先节点
tree_node* ldr_node = NULL;
tree_node* find_ldr(tree_node* ptr) {
	if (ptr == NULL)	return NULL;//遇到叶子节点就返回
	if (ptr->val == v1 || ptr->val == v2) return ptr;//返回找到的节点值
	tree_node* left = find_ldr(ptr->left);
	tree_node* right = find_ldr(ptr->right);
	if (left && right) return ptr;//如果左子树和右子树同时找到那么这个节点就是我们要找的节点
	return left == NULL ? right : left;
}
int main() {
	cin >> m >> n;
	inorder.resize(n);
	preorder.resize(n);
	for (int i = 0; i < n; i++) {
		cin >> inorder[i];
		flags[inorder[i]] = 1;
	}
	for (int i = 0; i < n; i++) {
		cin >> preorder[i];
	}
	tree_node* root = build_tree(0, n - 1, 0, n - 1);
	for (int ii = 0; ii < m; ii++) {
		cin >> v1 >> v2;
		if (flags[v1] == 0 && flags[v2] == 0) {
			printf("ERROR: %d and %d are not found.\n", v1, v2);
			continue;
		}
		else if (flags[v1] == 0) {
			printf("ERROR: %d is not found.\n", v1);
			continue;
		}
		else if (flags[v2] == 0) {
			printf("ERROR: %d is not found.\n", v2);
			continue;
		}
		ldr_node = find_ldr(root);
		if (ldr_node->val == v1) {
			printf("%d is an ancestor of %d.\n", v1, v2);
		}
		else if (ldr_node->val == v2) {
			printf("%d is an ancestor of %d.\n", v2, v1);
		}
		else {
			printf("LCA of %d and %d is %d.\n", v1, v2, ldr_node->val);
		}
	}
}