1143 Lowest Common Ancestor (30 分)

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.

A binary search tree (BST) is recursively defined as a binary tree which has the following properties:

The left subtree of a node contains only nodes with keys less than the node’s key.
The right subtree of a node contains only nodes with keys greater than or equal to the node’s key.
Both the left and right subtrees must also be binary search trees.
Given any two nodes in a BST, 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 BST, respectively. In the second line, N distinct integers are given as the preorder traversal sequence of the BST. 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 BST, 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
6 3 1 2 5 4 8 7
2 5
8 7
1 9
12 -3
0 8
99 99
结尾无空行

Sample Output:

LCA of 2 and 5 is 3.
8 is an ancestor of 7.
ERROR: 9 is not found.
ERROR: 12 and -3 are not found.
ERROR: 0 is not found.
ERROR: 99 and 99 are not found.
结尾无空行

Code

/**
 根据先序遍历递归的构建一颗二叉搜索树，记住只有完全二叉树才能使用中序下标 
**/
#include <iostream>
#include <vector>
#include <map>
using namespace std;
int pre[10000];
struct node{
	int val;
	node *left;
	node *right;
	node(int val) : val(val), left(nullptr), right(nullptr){};
};

node *build(int h, int t){
	if(h >= t)
		return nullptr;
	int rootVal = pre[h], i = h + 1;
	node *root = new node(rootVal);
	while(i < t && pre[i] < rootVal) i++;
	root->left = build(h + 1, i);
	root->right = build(i, t);
	return root;
}
void in(node *root){
	if(root){
		in(root->left);
		cout<<root->val;
		in(root->right); 
	}
}
//node* buildTree(node* root, int val){//会超时
//	
//	if(!root){
//		root = new node(val);
//	}else{
//		
//		if(val < root->val)
//			root->left = buildTree(root->left, val);
//		if(val >= root->val)
//			root->right = buildTree(root->right, val);
//	}
//	return root;
//}
int LCA(node* root, int u, int v){
	if(!root)
		return -1;

	if(u < root->val && v < root->val)
		return LCA(root->left, u, v);
	else if(u > root->val && v > root->val)
		return LCA(root->right, u, v);
	else 
		return root->val;
	
}
int main(){
	int n, m;// n paire 8 nods;
	scanf("%d%d", &n, &m);
	node *root = nullptr;
	
	map<int, int> book;//不用数组是因为负数下标有bug 
	for(int i = 0; i < m; i++){
		int t;
		scanf("%d", &t);
		pre[i] = t;
//		root = buildTree(root, t);//会超时 
		book[t] = 1;
	}
	root = build(0, m);
//	in(root);测试建树是否成功 
	int u, v;
	int res;
	while(n--){
		scanf("%d %d", &u, &v);
		if(book[u] == 0 && book[v] == 0){
			printf("ERROR: %d and %d are not found.\n", u, v);
			continue;
		}else if(book[u] == 0){
			printf("ERROR: %d is not found.\n", u);
			continue;
		}else if(book[v] == 0){
			printf("ERROR: %d is not found.\n", v);
			continue;
		}
		res = LCA(root, u, v);
		if(res == u){
			printf("%d is an ancestor of %d.\n", u, v);	
		}else if(res == v){
			printf("%d is an ancestor of %d.\n", v, u);	
		}
		else
			printf("LCA of %d and %d is %d.\n", u, v, res);
	}
}

Summary

这道题的LCA逻辑还算简单，就是给两个结点u、v假定它们存在，如果v和u都大于当前节点的值，就在右子树寻找。如果都小于就在左子树找，其余的情况就是当前节点为最小公共祖先（一左一右）
难点在于建树（个人而言），最开始的超时了，每输入一个结点就遍历一次树，因此需要利用搜索二叉树的特点，首先存取题目给的先序数组，之后，再总体建树，根据范围内数与当前根节点的大小划分左右子树，这里不取右端点。当头大于等于尾巴时返回空 。还有一个就是在结构体可以创建类似于java中的构造器
node(int val) : val(int val), left(nullptr), right(nullptr){}
还有就是用数组下标为负时容易出bug，map的插入方法因key类型而异