1143 Lowest Common Ancestor （30 分）通过中序和前序建树，求LCA

最新推荐文章于 2020-11-22 15:07:41 发布

zjykshen

最新推荐文章于 2020-11-22 15:07:41 发布

阅读量230

点赞数

分类专栏： PAT

本文链接：https://blog.csdn.net/qq_40916491/article/details/88052002

版权

PAT 专栏收录该内容

29 篇文章 1 订阅

订阅专栏

该博客介绍了如何解决一个给定二叉搜索树（BST）中，两个节点的最低公共祖先（LCA）问题。根据先序遍历序列，需要处理M对节点查询，并构建BST来找到LCA。博客提供了输入输出规格和示例，并提出了利用中序和前序遍历序列建树来求解LCA的方法。

摘要由CSDN通过智能技术生成

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.

题意：

给你一棵二叉排序树的先序序列，求每次询问的LCA（最近公共祖先）

思路：

题目已知是一棵二叉排序树，其实将每个结点排序后得出的即是中序遍历，即已知中序和前序，建树，然后求LCA

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn=10005;
int m,n;
struct node
{
	int data;
	node *lchild,*rchild;
};
bool cmp(int a,int b)
{
	return a<b;
}
int pre[maxn];
int in[maxn];
node *build(int prel,int prer,int inl,int inr)
{
	if(inl>inr)
	return NULL;
	int p1,p2;
	node *root=new node;
	root->data=pre[prel];
	p1=inl;
	while(in[p1]!=pre[prel])
	p1++;//p1是根的位置 
	p2=p1-inl;
	root->lchild=build(prel+1,prel+p2,inl,p1-1);
	root->rchild=build(prel+p2+1,prer,p1+1,inr);
	return root; 
}
node *lca(node *root,int u,int v)
{
	if(root==NULL)
	return NULL;
	if(root->data==u||root->data==v)
	return root;
	node *left=lca(root->lchild,u,v);
	node *right=lca(root->rchild,u,v);
	if(left&&right)
	return root;
	return left==NULL?right:left;
}
bool find(int u)//找是否存在于序列中 
{
	for(int i=0;i<n;i++)
	{
		if(u==pre[i])
		return true;
	}
	return false;
}
int main()
{
	scanf("%d%d",&m,&n);
	for(int i=0;i<n;i++)
	{
		scanf("%d",&pre[i]);
		in[i]=pre[i];
	}
	sort(in,in+n,cmp);
	//这样就得到了层次遍历和前序遍历 
	node *root=build(0,n-1,0,n-1);
	while(m--)
	{
		int u,v;
		scanf("%d%d",&u,&v);
		if(find(u)==false&&find(v)==false)
		printf("ERROR: %d and %d are not found.\n",u,v);
		else if(find(u)==false||find(v)==false)
		printf("ERROR: %d is not found.\n",find(u)==false?u:v);
		else
		{
			node *ans=lca(root,u,v);
			if(ans->data==u||ans->data==v)
			printf("%d is an ancestor of %d.\n",ans->data==u?u:v,ans->data==u?v:u);
			else
			printf("LCA of %d and %d is %d.\n",u,v,ans->data);
		}
	}
}