1143 Lowest Common Ancestor

题目大意

给定一棵BST树的先序遍历，再给出任意两个节点（不一定存在该节点），让你输出两个节点的最低公共祖先。

---

思路解析

本题有两种做法，下面分别介绍：
1. 法一：见到BST就要想到中序遍历、从小到大、先序还原的特性。但本题难就难在先序还原上。以前的做法都是按照先序序列逐个insert，但如果对于一棵单支树，也就是最差的情况复杂度将会上升到N的平方级。所以本题不能通过该方法建树，而是采用最原始的先序中序序列建树，这种方法可以降为logN。剩下的lca操作不变。
另外lca的普通解法附在了末尾，该方法同样也不会超时，需要掌握。
3. 法二：第二种就是投机取巧，如果在考场上大脑还足够活跃的话可以试试该法：在BST中两个节点与最低公共祖先必然是单调的。所以，从先序中找到第一个满足关系： u < pre[j] < v 的节点就是所求答案。

---

示例代码（法一）

#include<iostream>
#include<algorithm>
#include<vector>
#include<unordered_map>
using namespace std;
struct node{
public:
	int val;
	struct node* left, *right;
};
vector<int> pre, inorder;
node* build(node* tree, int l1, int r1, int l2, int r2) {
	if (l1 > r1) return NULL;
	if (l1 == r1) {
		node* nod = new node();
		nod->val = pre[l1];
		return nod;
	}
	int cnt = 0;
	int root;
	for (root = l2; root <= r2; root++) {
		cnt++;
		if (inorder[root] == pre[l1]) break;
	}
	tree = new node();
	tree->val = inorder[root];
	tree->left = build(tree->left, l1 + 1, l1 + cnt - 1, l2, root - 1);
	tree->right = build(tree->right, l1 + cnt, r1, root + 1, r2);
	return tree;
}
node* lca(node* tree, int a, int b) {//默认 a < b
	if (tree->val < a) return lca(tree->right, a, b);
	if (tree->val > b) return lca(tree->left, a, b);
	return tree;
}
int main() {
	int m, n;
	scanf("%d %d", &m, &n);
	pre.resize(n);
	inorder.resize(n);
	unordered_map<int, bool> mapp;
	node* tree = NULL;
	for (int i = 0; i < n; i++) {
		int val;
		scanf("%d", &val);
		pre[i] = val;
		mapp[val] = true;
	}
	inorder = pre;
	sort(inorder.begin(), inorder.end());
	tree = build(tree, 0, n - 1, 0, n - 1);
	for (int i = 0; i < m; i++) {
		int a, b;
		scanf("%d %d", &a, &b);
		if (mapp[a] == false && mapp[b] == false) {
			printf("ERROR: %d and %d are not found.\n", a, b);
		}
		else if (mapp[a] == false) {
			printf("ERROR: %d is not found.\n", a);
		}
		else if (mapp[b] == false) {
			printf("ERROR: %d is not found.\n", b);
		}
		else {
			node* root = lca(tree, min(a, b), max(a, b));
			if (root->val == a || root->val == b) {
				printf("%d is an ancestor of %d.\n", root->val, root->val == a ? b : a);
			}
			else {
				printf("LCA of %d and %d is %d.\n", a, b, root->val);
			}
		}
		
	}
	return 0;
}

示例代码（法二）

#include<iostream>
#include<vector>
#include<algorithm>
#include<map>
using namespace std;
int main() {
	int m, n;
	scanf("%d %d", &m, &n);
	vector<int> vec(n);
	map<int, int> order;
	for (int i = 0; i < n; i++) {
		scanf("%d", &vec[i]);
		order[vec[i]] = i;
	}
	for (int i = 0; i < m; i++) {
		int a, b;
		scanf("%d %d", &a, &b);
		int mi = min(a, b);
		int ma = max(a, b);
		if (order.find(a) == order.end() && order.find(b) == order.end()) {
			printf("ERROR: %d and %d are not found.\n", a, b);
		}
		else if (order.find(a) == order.end()) {
			printf("ERROR: %d is not found.\n", a);
		}
		else if (order.find(b) == order.end()) {
			printf("ERROR: %d is not found.\n", b);
		}
		else {
			bool flag = true;
			int root;
			for (int j = 0; j < n; j++) {
				root = vec[j];
				if (root >= mi && root <= ma) {
					break;
				}
			}
			if (root == a || root == b) {
				printf("%d is an ancestor of %d.\n", root, root == a ? b : a);
			}
			else {
				printf("LCA of %d and %d is %d.\n", a, b, root);
			}
		}
	}
	return 0;
}

LCA

node* lca(node* tree,int a, int b) {
	if (tree == NULL) return NULL;
	if (tree->val == a || tree->val == b) {
		return tree;
	}
	node* l = lca(tree->left, a, b);
	node* r = lca(tree->right, a, b);
	if (l != NULL &&r != NULL) {
		return tree;
	}
	if (l != NULL) {
		return l;
	}
	if (r != NULL) {
		return r;
	}
	return NULL;
}