1143. Lowest Common Ancestor (30)-PAT甲级真题 (LCA 二分法构造树)-CSDN博客

本文链接：https://blog.csdn.net/hzj913313180/article/details/130626542

文章目录

题意

给定排序树的结点数量n，再给出排序树的先序遍历序列。再询问m次，每次给出两个结点s、e，首先判断是否存在，然后找两个点的最近公共祖先LCA。

思路1 - 对应解法1（AC）

先用数组a接收输入的先序遍历序列，通过哈希表rec记录节点的存在位置rec[a[i]] = i;。
再循环m次：
- 每次接收两个节点s e，通过rec先确定是否存在。不存在时输出进入下层循环。
- 由先序序列和LCA特性，最近公共祖先是遍历序列时的第一个具备如下性质的数字：(tar - s) * (tar - e) == 0，（开始把性质推错了，结果在min(rec[s], rec[e])开始从右往左遍历，卡了好久，阿巴阿巴）

思路2 - 对应解法2（测试点4 - WA）

第一步同思路1
然后常规造树，建了一棵静态链表，pp数组指向节点的父亲。
再循环m次：
- 同思路1先确定是否存在。
- 然后通过mp、mp2两个哈希表分别记录s、e到根结点的路径上出现过的节点。
- 如果e出现在s中说明e是s的祖先，反之同理。
- 然后再遍历一趟s到根结点的路径，第一个出现在mp2中的结点是LCA。
到这里写完后提交。测试点4、测试点5都TLE了，思考是建树的时候找右子树起始位置il的时间复杂度为O(n)，于是改用二分查找，果不其然写了很长时间，要多回顾。找右侧性质a[m] >= a[l]的最左端应该是r = m, 对应于m = l + r >> 1;

int il = l + 1, ir = r;// 目的找第一个大于等于a[l]的位置 
while(il < ir){//出来时il == ir （初始也可能il == ir + 1直接跳出来） 
	int m = il + ir >> 1; 
	if(a[m] < a[l]) il = m + 1;
	else ir = m;
}

改正后测试点5仍然TLE，同时测试点4WA：分析测试点4是因为多个相同数字出现，测试点5是树太过不平衡。
做到1151时换了种做法，把记录路径的哈希表改为数组，测试点5就过了，但是测试点4仍然WA。这里注意哈希表的插入速度是 $O(log_2n)$ 慢于数组头插O(1)

总结

LCA特性，最近公共祖先是遍历序列时的第一个具备如下性质的数字：(tar - s) * (tar - e) == 0。
哈希表的插入速度是 $O(log_2n)$ 慢于数组头插O(1)。
能找到数学规律并用其解决问题的，就没必要用常规方法。

解法1 - (AC)

#include<bits/stdc++.h>
using namespace std;
int n, m, s, e, ptr, a[10001];
unordered_map<int, int> rec;
int main(){
	scanf("%d %d", &m, &n);
	for(int i = 1; i <= n; i ++){
		scanf("%d", &a[i]);
		rec[a[i]] = i;
	}
	while(m--){
		scanf("%d %d", &s, &e);
		int as = rec[s], ae = rec[e];
		if(as == 0 && ae == 0) printf("ERROR: %d and %d are not found.\n", s, e);
		else if(as * ae == 0) printf("ERROR: %d is not found.\n", as ? e : s);
		else{
			for(ptr = 1; ; ptr++)
				if((a[ptr] - s) * (a[ptr] - e) <= 0) break;
			if(a[ptr] == s || a[ptr] == e) 
				printf("%d is an ancestor of %d.\n", a[ptr], a[ptr] == s ? e : s);
			else printf("LCA of %d and %d is %d.\n", s, e, a[ptr]);
		} 
	}
	return 0;
}

解法2 - 建树 - (测试点4WA)

#include<bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, m, s, e;
int a[N], pp[N];
void mt(int l, int r, int p){
	if(l > r) return;
	pp[l] = p;
	if(l == r) return;
	/* 注释1
	int i = l + 1;
	while(i <= r && a[i] < a[l]) i++;
	mt(l + 1, i - 1, l);
	mt(i, r, l);
	*/
	int il = l + 1, ir = r;// 目的找第一个大于等于a[l]的位置 
	while(il < ir){//出来时il == ir （初始也可能il == ir + 1直接跳出来） 
		int m = il + ir >> 1; 
		if(a[m] < a[l]) il = m + 1;
		else ir = m;
	}
	mt(l + 1, il - 1, l);
	mt(il, r, l);
}
int main(){
	cin>>m>>n;
	unordered_map<int, int> rec;
	for(int i = 1; i <= n; i ++){
		scanf("%d", &a[i]);
		rec[a[i]] = i;
	}
	mt(1, n, 0);
	while(m--){
		scanf("%d %d", &s, &e);
		int as = rec[s], ae = rec[e];
		if(as == 0 && ae == 0) printf("ERROR: %d and %d are not found.\n", s, e);
		else if(as * ae == 0) printf("ERROR: %d is not found.\n", as == 0 ? s : e);
		else{
			deque<int> rec1, rec2;
			int start = as, ptr = 0;
			while(start != 0){
				rec1.push_front(a[start]);
				start = pp[start];
			}
			start = ae;
			while(start != 0){
				rec2.push_front(a[start]);
				start = pp[start];
			}
			while(ptr < rec1.size() && ptr < rec2.size() && rec1[ptr] == rec2[ptr]) ptr++;
			if(rec1[ptr - 1] == s) printf("%d is an ancestor of %d.\n", s, e);
			else if(rec1[ptr - 1] == e)printf("%d is an ancestor of %d.\n", e, s);
			else printf("LCA of %d and %d is %d.\n", s, e, rec1[ptr - 1]);
		/*注释2
			unordered_map<int, bool> mp, mp2;
			int start = as;
			while(start != 0){
				mp[start] = true;
				start = pp[start];
			}
			start = ae;
			while(start != 0){
				mp2[start] = true;
				start = pp[start];
			}
			if(mp[ae]) printf("%d is an ancestor of %d.\n", e, s);
			else if(mp2[as])printf("%d is an ancestor of %d.\n", s, e);
			else{
				start = as;
				while(start != 0){
					start = pp[start];
					if(mp2[start]){
						printf("LCA of %d and %d is %d.\n", s, e, a[start]);
						break;
					}
				}
			}
		}
		*/
	}
	return 0;
}

题目

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.