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.

 

 

这题是考搜索二叉树（查找二叉树bst），根据搜索二叉树的特点可知道中序排序是从小到大的排序，现在知道了前序排序，和中序排序，那么就可以建立一颗树

然后把符合条件的俩个点，带入从上到下的树来查找

具体代码体现

#include<iostream>
#include<cstdio>
#include<string>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
typedef struct node;
typedef node *bst;
struct node
{
	int val;
	bst L;
	bst R;
};
int n, m;
vector<int>p;
vector<int>mid;


void build(bst &root, int l1, int r1, int l2, int r2)
{
	if (l1>r1 || l2>r2) return;
	int pos = l2;
	while (mid[pos] != p[l1]) {
		pos++;
	}
	root = new node;
	root->val = p[l1];
	root->L = NULL;
	root->R = NULL;
	build(root->L, l1 + 1, l1 + pos - l2, l2, pos - 1);
	build(root->R, l1 + pos - l2 + 1,r1, pos + 1, r2);
}
void print(bst root)
{
	if (root) {
		cout << root->val << endl;
		print(root->L);
		print(root->R);
	}
}

bst findth(bst root,int u,int v)
{
	if ((u <= root->val&&v >= root->val) || (u >= root->val&&v <= root->val))
		return root;
	else {
		if (u < root->val&&v < root->val) findth(root->L, u, v);
		else if (u > root->val&&v > root->val) findth(root->R, u, v);
	}
}
int main()
{

	scanf("%d %d", &n, &m);
	map<int, bool> mp;
	for (int i = 0;i < m;i++) {
		int x;
		scanf("%d", &x);
		p.push_back(x);
		mp[x] = true;
	}
	mid = p;
	sort(mid.begin(), mid.end());
	bst root;
	build(root, 0, m - 1, 0, m - 1);
	for (int i = 0;i < n;i++) {
		int u, v;
		scanf("%d %d", &u, &v);
		if(!mp[u]&&!mp[v])  printf("ERROR: %d and %d are not found.\n", u, v);
		else if(!mp[u]) printf("ERROR: %d is not found.\n", u);
		else if(!mp[v]) printf("ERROR: %d is not found.\n", v);
		else {
			bst t = findth(root, u, v);
			if (t->val == u) printf("%d is an ancestor of %d.\n", u, v);
			else if (t->val == v) printf("%d is an ancestor of %d.\n", v, u);
			else printf("LCA of %d and %d is %d.\n", u, v, t->val);
		}
	}
	return 0;
}