每周一算法：倍增法求最近公共祖先（LCA）

最近公共祖先

最近公共祖先简称 LCA（Lowest Common Ancestor）。两个节点的最近公共祖先，就是这两个点的公共祖先里面，离根最远的那个。

题目链接

【模板】最近公共祖先（LCA）

题目描述

如题，给定一棵有根多叉树，请求出指定两个点直接最近的公共祖先。

输入格式

第一行包含三个正整数 $N,M,S$，分别表示树的结点个数、询问的个数和树根结点的序号。

接下来 $N-1$ 行每行包含两个正整数 $x,y$，表示 $x$ 结点和 $y$ 结点之间有一条直接连接的边（数据保证可以构成树）。

接下来 $M$ 行每行包含两个正整数 $a,b$，表示询问 $a$ 结点和 $b$ 结点的最近公共祖先。

输出格式

输出包含 $M$ 行，每行包含一个正整数，依次为每一个询问的结果。

样例 #1

样例输入 #1

5 5 4
3 1
2 4
5 1
1 4
2 4
3 2
3 5
1 2
4 5

样例输出 #1

4
4
1
4
4

提示

对于 $30\%$ 的数据，$N\le 10$，$M\le 10$。

对于 $70\%$ 的数据，$N\le 10000$，$M\le 10000$。

对于 $100\%$ 的数据，$1\le N,M\le 500000$，$1\le x,y,a,b\le N$，不保证 $a\ne b$。

样例说明：

该树结构如下：

第一次询问：$2,4$ 的最近公共祖先，故为 $4$。

第二次询问：$3,2$ 的最近公共祖先，故为 $4$。

第三次询问：$3,5$ 的最近公共祖先，故为 $1$。

第四次询问：$1,2$ 的最近公共祖先，故为 $4$。

第五次询问：$4,5$ 的最近公共祖先，故为 $4$。

故输出依次为 $4,4,1,4,4$。

算法思想

朴素算法

可以每次找深度比较大的那个点，让它向上跳。显然在树上，这两个点最后一定会相遇，相遇的位置就是想要求的 LCA。 或者先向上调整深度较大的点，令他们深度相同，然后再共同向上跳转，最后也一定会相遇。

朴素算法预处理时需要 dfs 整棵树，时间复杂度为 $O(n)$，单次查询时间复杂度为 $O(n)$。如果树满足随机性质，则时间复杂度与这种随机树的期望高度有关。

倍增法

倍增算法是最经典的 LCA 求法，是朴素算法的改进算法。通过预处理 $f[i][j]$ 数组，可以大幅减少了跳转次数。 $f[i][j]$ 表示点 $i$ 的第 $2^j$ 个祖先。 $f[i][j]$ 数组可以通过 dfs 预处理出来。

根据倍增思想，$f[i][j]=f[f[i][j-1]][j-1]$。

寻找$\text{LCA}(x,y)$过程可以分为两个阶段：

• 第一阶段中，将 $x,y$ 两点跳转到同一深度。
• 在第二阶段中，从最大的 $i$ 开始循环尝试，一直尝试到 $0$（包括 $0$），如果$f[x][i]\ne f[y][i]$，则 $x\leftarrow f[x][i],y\leftarrow f[y][i]$，那么最后的 LCA 为 $f[x][0]$（或$f[y][0]$）。

时间复杂度

• 倍增算法的预处理时间复杂度为$O(n\log n)$
• 单次查询时间复杂度为 $O(\log n)$

代码实现

#include <iostream>
#include <vector>
using namespace std;
const int N = 5e5 + 5, M = 25;
vector<int> g[N];
int depth[N], f[N][M];
void dfs(int i, int fa)
{
    depth[i] = depth[fa] + 1;
    f[i][0] = fa; //初始状态
    //计算状态f[i][j]表示从i节点开始向上2^j个祖先
    for(int j = 1; j <= 20; j ++) f[i][j] = f[f[i][j - 1]][j - 1];
    for(int j : g[i]) if(j != fa) dfs(j, i);
}
int lca(int x, int y)
{
    if(depth[x] < depth[y]) swap(x, y);
    for(int k = 20; k >= 0; k --) //从大到小枚举向上跳的距离，直到跳到和y相同的高度
    {
        if(depth[f[x][k]] >= depth[y]) x = f[x][k];
    }
    if(x == y) return x;
    for(int k = 20; k >= 0; k --)
    {
        if(f[x][k] != f[y][k]) //只要祖先节点不相等就继续向上跳
        {
            x = f[x][k], y = f[y][k];
        }
    }
    return f[x][0]; //返回x或y的父节点
}
int main()
{
    int n, m, s;
    scanf("%d%d%d", &n, &m, &s);
    for(int i = 1; i < n; i ++)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        g[a].push_back(b), g[b].push_back(a);
    }
    dfs(s, 0);
    while (m -- )
    {
        int x, y;
        scanf("%d%d", &x, &y);
        int ans = lca(x, y);
        printf("%d\n", ans);
    }
}