最近公共祖先(LCA)

合集 - 算法笔记(2)

1.算法笔记 - 树的直径2024-03-27

2.最近公共祖先(LCA)2024-03-28

收起

$\text{LCA}$

定义 性质：

在有根树上，$\text{LCA}$ 是指一个点集的公共祖先中深度最大的点。

• $\text{LCA}$ 具有可并性。

• $\text{LCA}(u,v)$ 在 $u,v$ 间的路径上。

• 设 $h(i)$ 表示 $i$ 与根的距离，则两点 $u,v$ 的距离 $=h(u)+h(v)-2h(\text{LCA}(u,v))$。

求法：

倍增。

设 $f{a}_{u,i}$ 表示 $u$ 的第 $2^i$ 级祖先，在求 $\text{LCA}(u,v)$ 时，先将 $u,v$ 跳转到同一深度，再枚举 $k$，尝试将 $u,v$ 跳到自己的 $k$ 级祖先，并保证不会多跳到它们的公共祖先上，即保证它们不同，如果它们不相等，则跳，否则不跳。

到最后时，$u,v$ 恰好是 $\text{LCA}$ 的孩子，$f{a}_{u,0}$ 即为 $u,v$ 的 $\text{LCA}$。

预处理 $fa$ 的方法：$DFS$，$f{a}_{u,0}$ 为自己的父亲，因为 $2^{i-1}+2^{i-1}=2^i$，所以 $u$ 的第 $2^{i-1}$ 级祖先的第 $2^{i-1}$ 级祖先就是 $u$ 的第 $2^{i-1}+2^{i-1}=2^i$ 级祖先，所以转移方程为：

$$f{a}_{u,i}=f{a}_{f{a}_{u,i-1},i-1}$$

时间复杂度：设询问 $m$ 次，$\mathrm{\Theta }(n\log n+m\log n)$。

代码：

#include<iostream>
#include<vector>
#define int long long
using namespace std;
 
const int N = 500010;
int lg[N];
 
int n, m, rt;
vector<int> G[N];
int de[N], fa[N][25];
 
void dfs(int fat, int u) // 预处理
{
    fa[u][0] = fat;
    de[u] = de[fat] + 1; // 初始化
    for(int i=1; i<=lg[de[u]]; i++)
        fa[u][i] = fa[fa[u][i-1]][i-1]; // 转移
    for(int i=0; i<G[u].size(); i++)
    {
        int v = G[u][i];
        if(v == fat)
            continue;
        dfs(u, v); // 搜索
    }
}
 
int LCA(int x, int y)
{
    if(de[x] < de[y]) // 保证y深于x，便于计算
        swap(x, y);
    while(de[x] > de[y])
        x = fa[x][lg[de[x] - de[y]] - 1]; // 统一深度
    if(x == y)
        return x; // 特判
    for(int k=lg[de[x]]-1; k>=0; k--)
        if(fa[x][k] != fa[y][k])
            x = fa[x][k],
            y = fa[y][k]; // 跳转到LCA的下方
    return fa[x][0];
}
 
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    for(int i=1; i<N; i++)
        lg[i] = lg[i-1] + ((1 << lg[i-1]) == i);
    cin >> n >> m >> rt;
    for(int i=1; i<n; i++)
    {
        int u, v;
        cin >> u >> v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    dfs(0, rt);
    while(m --)
    {
        int x, y;
        cin >> x >> y;
        cout << LCA(x, y) << '\n';
    }
    return 0;
}