51nod 2599 最近公共祖先(LCA) （ST表求LCA模板）

51nod 2599 最近公共祖先(LCA)

题目

裸 LCA，给一颗 n 个节点， n-1 条边的树，m次查询求任意两点LCA。

算法介绍

求 $LCA$ 可以用离线 $Tarjian$算法，算法复杂度O（n + m）。

还有一种离线的算法，预处理O（nlogn），在线查询O（1）。就是用$ST$表求LCA。

首先介绍欧拉遍历序，给一颗树，从根节点遍历：

欧拉遍历序为：1 2 3 2 4 2 5 2 1 6 7 6 8 6 1
节点深度 ：0 1 2 1 2 1 2 1 0 1 2 1 2 1 0

如果按照上面的顺序走一遍就会发现欧拉序就是 dfs遍历这颗树经过每个节点的顺序。
序列个数为 $2n-1$。

现在记录下每个节点第一次出现的顺序，那么任意节点的 LCA 就是这两个点第一次出现的位置之间深度最小的点
（将树看成一个无向图，u和v的公共祖先一定在u与v之间的最短路径上）

算法实现，我们会用到欧拉序，节点深度数组。这两个都可以对树进行一次$dfs$遍历得到，而求两点区间最值则可以用 $ST$表来预处理一下。注意$ST$表存的是下标，但是比较的时候要用下标对应的深度来比较

实现

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll mod = 9999991;
const ull base = 23333;
const int N = 1e4 + 10;

vector<int> tr[N];		// 邻接表存图
int vs[N];				// 第 i 次访问节点的编号
int depth[N]; 			// 第 i 次访问节点的深度
int id[N];				// 在 vs 数组中 i 节点第一次出现的下标
int vis[N];				// 标记数组
int st[N][20];			// 存最小值对应的下标
int n, m, x, y;				// 图的顶点，查询次数
int dfs_clock = 1;

// 求欧拉序
void dfs(int u, int d){		// 当前点，它的父节点，点深度
	id[u] = dfs_clock;
	vs[dfs_clock] = u;
	depth[dfs_clock++] = d;
	for(auto x : tr[u]){
		if(vis[x])					// 访问过不再访问
			continue;
		vis[x] = 1;
		dfs(x, d + 1);
		vs[dfs_clock] = u;			// 回溯节点也要记录
		depth[dfs_clock++] = d;
	}
}

void RMQ(int nn){
	for (int i = 1; i <= nn; i++){
		st[i][0] = i;
	}
	for (int j = 1; (1 << j) <= nn; j++){
		for (int i = 1; i + (1 << j) - 1 <= nn; i++){
			int a = st[i][j-1];
			int b = st[i + (1 << (j - 1))][j - 1];
			if(depth[a] <= depth[b]){   	// 存最小深度对应下标
				st[i][j] = a;
			}else{
				st[i][j] = b;
			}
		}
	}
}

int LCA(int u, int v){
	int l = id[u];
	int r = id[v];
	if(l > r)
		swap(l, r);
	int k = log2(r - l + 1);
	int a = st[l][k];
	int b = st[r - (1 << k) + 1][k];
	return depth[a] > depth[b] ? vs[b] : vs[a];
}

int main()
{
	scanf("%d", &n);
	for(int i = 0; i < n-1; i++){
		scanf("%d%d", &x, &y);
		tr[x].push_back(y);
		tr[y].push_back(x);
	}
	vis[1] = 1;
	dfs(1, 0);
	RMQ(dfs_clock - 1);
	scanf("%d", &m);
	while(m--){
		scanf("%d%d", &x, &y);
		printf("%d\n", LCA(x, y));
	}
	return 0;
}

/*
	   1	 
     2   3
	4 5
5
1 2
1 3
2 4
2 5

vs   : 1 2 4 2 5 2 1 3 1
depth: 0 1 2 1 2 1 0 1 0
id   : 1 2 8 3 5
*/