【模板】最近公共祖先（LCA）——暴力+倍增

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

题目描述

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

输入格式

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

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

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

输出格式

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

输入样例 #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$。

2021/10/4 数据更新 @fstqwq：应要求加了两组数据卡掉了暴力跳。

思路1——暴力

1. 先将要寻找最近公共祖先的两个节点上提至距离根节点更近的那个节点的高度
2. 再将两个节点持续上提，知道两节点相遇
   
   假设我们要找2和6的最近公共祖先，由于2距离根节点更近，所以我们先将6上提至4的位置。再将两个节点同上上提到1的位置，而此时两点相遇，所以2和6的最近公共祖先为1
   核心代码如下：

//father表示每个点的父节点，dis表示每个点的深度
int father[100], dis[100];
int LCA(int a,int b){
	//在函数中确保a更深
	if(dis[a] < dis[b]){
		swap(a, b);
	}
	//让b不断地跳到他的父节点上，直到与a的高度相同 
	while(dis[a] < dis[b]){
		b = father[b];
	}
	//让a和b同时往上跳，直到两者相遇为止
	while(a != b){
		a = father[a];
		b = father[b];
	}
	return a;
}

由于这里是一步一步向上跳，操作会重复多次，且时间复杂度较大，我们需要考虑使用新的方法——倍增

思路2——倍增思想

1. 第一步与暴力的思想相同，都是将两个点上提至同一高度
2. 第二步有所不同，我们不选择一步一步向上跳了，而是倍增的往上跳（即先对n进行二进制拆位，每次跳$2^i$次方）

#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
vector<int> G[N];
int n, m, s;
int fa[N][20];//fa[x][j]=y：x的2^j倍的祖先节点是y
int dep[N];//dep[x]=y：x节点的深度为y
int Log[N];
void dfs(int u, int f){
	//u当前访问的节点  f的u父节点
    fa[u][0] = f;//更新父节点信息
    dep[u] = dep[f] + 1;//更新深度信息
	//遍历u的邻接点
    for(int i = 0; i < G[u].size(); i++){
    	int v = G[u][i]; 
        if(v == f) continue;
        dfs(v, u);
    }
}
int lowbit(int x){
    return x & (-x);
}
int lca(int x, int y){
    //1.提至同一深度
    if(dep[x] < dep[y]){//在函数中确保x更深
    	swap(x, y);
    }
    for(int i = dep[x] - dep[y]; i; i -= lowbit(i)){//二进制拆位上移
        x = fa[x][Log[lowbit(i)]];
    }
        
    //2.同时上提
    for(int i = Log[n]; i >= 0; i--){
        if(fa[x][i] == fa[y][i]) continue;
        x = fa[x][i]；
        y = fa[y][i];
    }
    if(x == y){
    	return x;//假如两个点本身就在一起，直接返回
    }
    return fa[x][0];
}
int main(){
    cin >> n >> m >> s;
    for(int i = 1; i < n; i++){
        int x, y;
        cin >> x >> y;
        g[x].push_back(y);
        g[y].push_back(x);
    }

    dfs(s, 0);
    for(int i = 2; i <= n; i++) Log[i] = Log[i/2] + 1;//初始化
    for(int j = 1; j <= Log[n]; j++) //倍增求fa[i][j]
        for(int i = 1; i <= n; i++)
            fa[i][j] = fa[fa[i][j - 1]][j - 1];

    while(m--){
        int x, y;
        cin >> x >> y;
        cout << lca(x, y) << "\n";
    }
    return 0;
}