LCA 三种姿势（倍增，Tarjan+并查集，树链剖分）

1.倍增求 LCA $O((n+m)logn)$

1. $dep[u]$ 表示 $u$ 节点的深度。
2. $fa[u][i]$ 表示从 $u$ 节点向上跳跃 $2^i$ 层的祖先节点。

Q1：为什么要定义成 $2^i$ , $3^i$ 不是更快？

主要是因为需要用到二进制拆分，所有的数可以表示成某些 2 的次幂的和。

vector<int>e[N];
int dep[N],fa[N][20];

打表：倍增递推，从小到大枚举
void dfs(int u,int father){
    dep[u] = dep[father] + 1;
    fa[u][0] = father;
    for(int i=1;i<=19;i++){
        fa[u][i] = fa[fa[u][i-1]][i-1];
    }
    for(int v:e[u]){
        if(v!=father)dfs(v,u);
    }
}
int lca(int u,int v){
    if(dep[u] < dep[v])swap(u,v);
    // 2进制拆分，从大到下跳跃
    for(int i=19;i>=0;i--){
        // u不能跳到v上边去
        if(dep[fa[u][i]]>=dep[v])
            u = fa[u][i];
    }
    // v恰好是u的lca
    if(u == v)return v;
    // u,v一起跳
    for(int i=19;i>=0;i--){
        // 不能越界,一块跳到lca的下一个节点。
        if(fa[u][i] != fa[v][i]){
            u = fa[u][i];
            v = fa[v][i];
        }
    }
    return fa[u][0];
}

y总的板子：
void bfs(int root)
{
    memset(depth, 0x3f, sizeof depth);
    depth[0] = 0, depth[root] = 1;
    int hh = 0, tt = 0;
    q[0] = root;
    while (hh <= tt)
    {
        int t = q[hh ++ ];
        for (int i = h[t]; ~i; i = ne[i])
        {
            int j = e[i];
            if (depth[j] > depth[t] + 1)
            {
                depth[j] = depth[t] + 1;
                q[ ++ tt] = j;
                fa[j][0] = t;
                for (int k = 1; k <= 15; k ++ )
                    fa[j][k] = fa[fa[j][k - 1]][k - 1];
            }
        }
    }
}

int lca(int a, int b)
{
    if (depth[a] < depth[b]) swap(a, b);
    for (int k = 15; k >= 0; k -- )
        if (depth[fa[a][k]] >= depth[b])
            a = fa[a][k];
    if (a == b) return a;
    for (int k = 15; k >= 0; k -- )
        if (fa[a][k] != fa[b][k])
        {
            a = fa[a][k];
            b = fa[b][k];
        }
    return fa[a][0];
}

感觉 dfs 更短一些。

2.Tarjan离线求 LCA $O((n+m))线性！$

1. $fa[u]$ 表示 $u$ 节点的父亲节点。
2. $vis[u]$ 标记数组，防止向回深搜
3. 非常有特点的 vector<pair<int,int>>query[N] 表示 query[u]={v,i} 表示第 $i$ 次询问 $(u,v)$ 的 $LCA$ 是什么。
4. 每个查询必须正反建立一次！，不然结果不对

query[u] = {v,i};
query[v] = {u,i};

vector<int>e[N];
vector<pair<int,int>>query[N];
int fa[N],vis[N],ans[M];

int find(int u){ // 带路径压缩
    return fa[u] == u ? fa[u] : fa[u] = find(fa[u]);
}
void tarjan(int u){
	vis[u] = 1;
    for(auto j:e[u]){ // O(n)
        if(!vis[j]){
            tarjan(j);
            fa[j] = u; // 返回u时，j指向他的父亲u
        }
    }
    // 离开u时，枚举以u为起点的LCA询问。 O(m)
    for(auto q:query[u]){
        int v = q.first;
        int i = q.second;
        if(vis[v]){
            ans[i] = find(v); 
		}
    }
}

3.树链剖分求 LCA $O((n+m(查询次数)logn))$

前置知识：

重儿子 ：父节点的所有儿子中子树节点最多的节点 （如果有多个重儿子，任选一个）。
轻儿子：父节点中除重儿子以外的儿子，（根也是轻儿子）。
重边：父节点和重儿子连成的边。
轻边：父节点和轻儿子连成的边。
重链： 由多条重边连接而成的路径，独立的节点自身也是重链。

1. 整棵树会被剖分成若干条重链。
2. 轻儿子一定是每条重链的顶点。
3. 任意一条路径被切分成不超过 $O(logn)$ 条链。

$fa[u]$ ： $u$ 的父节点。
$dep[u]$ ：$u$ 的深度
$son[u]$ ： $u$ 的重儿子。
$sz[u]$ ： $u$ 为根子树节点数。
$top[u]$ ： $u$ 所在重链的顶点。

流程：

1. 第一遍 dfs，预处理 $fa[],dep[],son[],sz[]$
2. 第二遍 dfs，预处理 $top[]$
3. 做 $LCA$

轻儿子的链头一定是他自身，叶节点没有重儿子。

vector<int>e[N];
int fa[N],dep[N],son[N],sz[N];
int top[N];

void dfs1(int u,int father){ // O(n)
    fa[u] = father,dep[u] = dep[father]+1,sz[u]=1;
    for(int j:e[u]){
        if(j==u)continue;
        dfs1(j,u);
        // 回溯之后更新子树节点数目和重儿子
        sz[u] += sz[v];
        if(sz[son[u]] < sz[v])son[u] = v;
    }
}

void dfs2(int u,int t){ // 处理top数组,t记录重链头节点  O(n)
    top[u] = t;
    if(!son[u]) return ; // 遍历到了叶节点
    dfs2(son[u],t); // 先欧重儿子
    for(int j:e[u]){
        if(j == fa[u] || j == son[u])continue;// 特判重复边和指向重儿子的边
        dfs2(j,j); // 搜轻儿子
    }
}
int lca(int u,int v){ // O(log n )
    while(top[u]!=top[v]){
        if(dep[top[u]] < dep[top[v]])swap(u,v);
        u = fa[top[u]];
    }
    // u,v在同一条重链上，谁的深度浅返回谁。
    return dep[u] < dep[v] ? u : v;
}

再次回顾：