浅谈LCA（最近公共祖先）

LCA，全称Lowest Common Ancestor，也就是我们常说的最近公共祖先，即在一个有根树中，两个结点公共祖先中最近的那个，非常地通俗易懂。。

举个例子：

以4，5两个结点为例，他们的公共祖先有1，2，2相对来说要近一些，所以lca（4，5）= 2。

怎么实现呢？

最笨最粗暴的方式就是：

若两结点在同一深度，那么两点同时往上走，直到走到相同的点为止；反之，就先把更深的那个点走上来，然后就变成了前面一种情况。

代码：

#include<iostream>
#include<vector>
using namespace std;

vector<int> g[100010];

int rt;
int fa[100010], dep[100010];

void dfs(int v, int p, int d) {
	fa[v] = p;
	dep[v] = d;
	for (int i = 0; i < g[v].size(); i++) {
		if (g[v][i] != p) dfs(g[v][i], v, d + 1);
	}
}

int lca(int u, int v) {
	if (dep[u] > dep[v]) swap(u, v);
	while (dep[v] > dep[u]) {
		v = fa[v];
	}
	while (u != v) {
		u = fa[u];
		v = fa[v];
	}
	return u;
}

int main() {
	int n, q;
	cin >> n >> q;
	for (int i = 1; i < n; i++) {
		int a, b;
		cin >> a >> b;
		g[a].push_back(b);
		g[b].push_back(a);
	}
	rt = 1;
	dfs(rt, -1, 0);
	while (q--) {
		int a, b;
		cin >> a >> b;
		cout << lca(a, b) << endl;
	}
	return 0;
}

不难发现这种方法在n过大的情况下容易爆掉，所以我们要想办法优化。

能够达到目的的算法有倍增和RMQ（区间最值查询），这里主要讲倍增法。

倍增法高效实现LCA

通过分析上一种算法我们会发现它之所以不够高效就是因为每次两个结点只往上走一步，当遇到需要走很多个一步的情况时就很容易爆掉，所以我们考虑使用倍增。简单来说就是每次我都往上走尽可能多的步数，这样时间复杂度就下来了。

代码：

#include<iostream>
#include<vector>
using namespace std;

vector<int> g[10010];

int rt, n, q;

int fa[40][10010], dep[10010];

void dfs(int v, int p, int d) {
	fa[0][v] = p;
	dep[v] = d;
	for (int i = 0; i < g[v].size(); i++) {
		if(g[v][i] != p) dfs(g[v][i], v, d + 1);
	}
}

void init() {
	dfs(rt, -1, 0);
	for (int k = 0; k < 31; k++) {
		for (int v = 1; v <= n; v++) {
			if (fa[k][v] < 0) fa[k + 1][v] = -1;
			else fa[k + 1][v] = fa[k][fa[k][v]];
		}
	}
}

int lca(int u, int v) {
	if (dep[u] > dep[v]) swap(u, v);
	for (int k = 0; k < 32; k++) {
		if ((dep[v] - dep[u]) >> k & 1) {
			v = fa[k][v];
		}
	}
	if (u == v) return u;
	for (int k = 31; k >= 0; k--) {
		if (fa[k][u] != fa[k][v]) {
			u = fa[k][u];
			v = fa[k][v];
		}
	}
	return fa[0][u];
}

int main() {
	cin >> n >> q;
	for (int i = 1; i < n; i++) {
		int a, b;
		cin >> a >> b;
		g[a].push_back(b);
		g[b].push_back(a);
	}
	rt = 1;
	init();
	while (q--) {
		int a, b;
		cin >> a >> b;
		cout << lca(a, b) << endl;
	}
	return 0;
}

RMQ高效实现LCA

这里先补充个东西，叫dfs序，顾名思义，就是说用dfs遍历一棵树时，把整个遍历过程用每个结点的序号按照它们被遍历到的顺序表示出来的一个序列。

举个例子：

从1开始dfs遍历整棵树，则它的dfs序为：1 2 4 2 5 6 5 2 1 3 7 3 1

应该能看懂吧QAQ

那么LCA（u，v）就变成了访问到其中一个点后在访问到另一个点之前访问的距离根结点最近的那个结点，也就变成我们非常熟悉的RMQ了。有点绕QAQ

暂无代码自己敲去QwQ