1143 Lowest Common Ancestor

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的做法，像倍增，但不是的，没倍增
这题就2块，一建树，二LCA
可能看了很多模板，所以这题我觉得难在建树上面= =，没错，就是建树，LCA的判断需要和节点的深度有关，所以建树要多一个深度，BST树嘛，它的中序遍历是有序的，这点又忘记了，然后根据先序和中序建BST树
建树，以往经验，要么指针，要么静态，不行，脑子是真的转不动了，
算法笔记上的建树是把先序的左右，中序的左右都写进去，这只要5个参数
（当前根，中序L,中序R，父亲节点，深度），因为没怎么这么写过，所以第一次看很难受，然后递归的时候当前的根就后成为它左右子树的根节点，嗯，没毛病，不要在意结构体数组的下标，它只是用来承载信息的，会被连接成一个二叉树的，

===================================================================
总之，按照先序的顺序i(0<i<n)，给每个i构造函数，主要包括深度和父亲节点，然后根据i==0是根节点，从根节点建树，关于LCA嘛，我也没怎么细说，不会的自己学一下吧，我也讲不好，严格来说这并不是LCA的真正写法，LCA（倍增）只要是用二进制的思想，甲级貌似也不怎么卡时间吧，太有好了（主要是脑子动不了了）

#include<cstdio>
#include<algorithm>
const int N=10005;
using namespace std;
struct node{
	int v,p,d;
	node(int v=0,int p=-1,int d=0):v(v),p(p),d(d){};
}t[N];
int n,m,in[N],pre[N];
void create(int root,int l,int r,int p,int d){
	if(l > r) return ;
	int i=l;
	while(i<=r && in[i]!=pre[root]) i++;
	t[root]=node(pre[root],p,d);
	create(root+1,l,i-1,root,d+1);
	create(root+1+i-l,i+1,r,root,d+1); 
}
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);
	create(0,0,n-1,-1,0);
	for(int i=0;i<m;i++){
		int a,b;
		scanf("%d%d",&a,&b);
		int ain=n,bin=n;
		for(int i=0;i<n;i++){
			if(pre[i] == a) ain=i;
			if(pre[i] == b) bin=i;
		}
		if(ain == n && bin == n){
			 printf("ERROR: %d and %d are not found.\n",a,b);
		}else if(ain==n){
            printf("ERROR: %d is not found.\n",a);
        }else if(bin==n){
            printf("ERROR: %d is not found.\n",b);
        }else{
        	bool f =true;
        	if(t[ain].d <t[bin].d ){
        		swap(ain,bin);
        		f=false;
			}
			while(t[ain].d > t[bin].d) ain=t[ain].p;
			if(ain == bin){
				int son;
				if(f) son = a;
				else son =b;
				printf("%d is an ancestor of %d.\n",t[ain].v,son);
			}else{
				while(ain!=bin){
					ain=t[ain].p;
					bin=t[bin].p;
				}
				printf("LCA of %d and %d is %d.\n",a,b,t[ain].v);
			}
		}


	}
	
	return 0;
}

还有一个类似的A1151，留着考前做，这题明天一定要在复习一遍
参考