倍增法求LCA(笔记)

LCA:

lca就是最近公共祖先，对于上任意两个点，向上进项追溯，遇到第一个他们共有的祖先就是lca，注意，lca可以是两个点中的其中一个，也可以两个点重合。

倍增算法：

我们先考虑不适用倍增的做法，很自然我们能想到爬楼梯做法，即我们由两个点向上一层一层追溯O(n)的复杂度来找出lca。但是这样对多个查询一下子就T了，所以我们就考率在向上爬时做一下变动，我们之所以慢是因为我们爬的太慢，所以我们尝试让每次爬的多一点：

1.对于所有的点我们先计算他们深度$O(n)$
2.对于任意两点，如果他们深度不同，就让深度深的往上爬直到两者相同。

如果两者的深度差为x，那么怎么样才能快速爬又不会爬错位呢？我们知道任何一个数都可以拆成二进制，所以我们也把x进行二进制拆分，然后我们依次爬$2^i$补就可以了
3.计算每个点向上爬$2^i$次爬到的位置
4.两个点同时向上爬直到他们的父亲相同(用一个数组储存即fa数组)

fa数组求法：

fa[endd][j] = fa[fa[endd][j - 1]][j - 1];

表示endd向上爬$2^i$步所能到达的节点，这里的求法类似于dp

例题

#include<bits/stdc++.h>
#define ll long long
#define eps 1e-8
#define INF 0x3f3f3f3f
#define pb push_back
#define endl '\n'
using namespace std;
const ll maxn = 2e6 + 5;
ll h[maxn],nex[maxn],cnt = 1,e[maxn];
ll a,b,c,n,m,dep[maxn],f[maxn][25],r;
void add(int a,int b){
    e[cnt] = b;
    nex[cnt] = h[a];
    h[a] = cnt++;
}
void bfs(){
    queue<int> qu;
    qu.push(r);
    dep[r] = 1;
    while(qu.size()){//bfs求fa和dep
        int t = qu.front();
        qu.pop();
        for(int i = h[t]; i ; i = nex[i]){
            int endd = e[i];
            if(!dep[endd]){
                dep[endd] = dep[t] + 1;
                f[endd][0] = t;
                qu.push(endd);
                for(int j = 1; j <= c; j++)
                    f[endd][j] = f[f[endd][j - 1]][j - 1];
            }
        }
    }
}
int lca(int a,int b){
    if(dep[a] < dep[b])swap(a,b);
    for(int i = c; i >= 0; i--)//跳到同一层
        if(dep[f[a][i]] >= dep[b])
            a = f[a][i];
    if(a == b) return a;
    for(int i = c; i >= 0; i--)//一起向上跳
        if(f[a][i] != f[b][i])
            a = f[a][i],b = f[b][i];
    return f[a][0];//返回父亲
}
int main(){
    ios::sync_with_stdio(false);
    scanf("%d %d %d",&n,&m,&r);
    c = (log(n) / log(2)) + 1;
    for(int i = 1; i <= n - 1; i++)
        scanf("%d %d",&a,&b),add(a,b),add(b,a);
    bfs();
    while(m--){
        scanf("%d %d",&a,&b);
        printf("%d\n",lca(a,b));
    }
    return 0;
}