【模板】LCA

找最近公共祖先有几步？
打开冰箱，把大象放进去，再把门关上
虽然但是，真寄吧难
本集内容有：
1 链式前向星加边
2 一边dfs一边递推
3 生活在树上

题目描述

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

输入格式

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

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

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

输出格式

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

输入输出样例

输入

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

输出

4
4
1
4
4

解决办法

1 先跳到相同深度（用倍增优化

2 再跳到他们相遇为止，重合就不跳（用倍增优化

一开始啥都不会，就到处看看。

总结出来就这两步。但是这两步不好搞啊

先建图。（我链式前向星又忘了）
需要先预处理出所有点的深度。（就会个DFS）
还要预处理出每个点倍增找祖先节点的“地图”（倍增（DP？不会。））
然后就能让两个点跳到相同深度
跳怎么理解？把x放在新地方（修改x的值）

假设跳到同样高度以后，节点x和y的深度都为d
再假设LCA所在的深度为dL
再假设向上跳的深度为dJ

那么 dL>=d-dJ 时，x和y永远重合
dL<d-dJ 时，x和y永远不重合

也就是说，只要从大往小地枚举往上跳的阶数，并且
只在x和y不会重合的时候让他们跳上去，直到不能往上跳为止。

下面是代码，倍增和建图的操作解释见注释

//找到LCA的思路：
//1 先跳到相同深度（用倍增优化
//2 再跳到他们相遇为止，重合不跳（用倍增优化

#include<iostream>
#include<algorithm>
#include<cmath>
#define maxn 1050000
using namespace std;
//参照大佬
//https://www.bilibili.com/video/BV1mJ411S7BB
//链式前向星可以理解为邻接表的一种简化，加边的方式像链表的头插。（这下懂了）
struct edge{
    int next;
    int to;
}edge[maxn];
int head[maxn];
int n,m,root,cnt;
int f[maxn][22],dep[maxn];

void init(){
    for(int i=1;i<=maxn;i++){
        head[i]=-1;//链式前向星初始化
    }
    cnt=0;
}

void add(int x,int y){
    edge[++cnt].next=head[x];//我喜欢从下标1开始
    edge[cnt].to=y;
    head[x]=cnt;
}

void dfs(int x,int fa){//x当前节点 fa是x的父节点
    dep[x]=dep[fa]+1;//更新深度信息。（儿子是爸爸的后辈）
    //这就是大名鼎鼎的倍增啦
    //f[i][j]表示 i 节点往根方向 2^j 层到达的节点。   
    f[x][0]=fa;//表示x往上一层是fa
    for(int i=1;(1<<i)<=dep[x];i++){
        f[x][i]=f[f[x][i-1]][i-1];
        //向上走 2^i 层等于先走 2^(i-1) 层，再走 2^(i-1)层
    }
    for(int i=head[x];i!=-1;i=edge[i].next){
        if(edge[i].to!=fa)//因为加边时候双向加边
            dfs(edge[i].to,x);//所以要判断一下不能往回走。
            //绝对要记住
    }
}

int lca(int x,int y){//不多说了，见上
    if(dep[x]<dep[y]) swap(x,y);
    for(int i=20;i>=0;i--){
        if(dep[x]-(1<<i)>=dep[y])
            x=f[x][i];
    }
    if(x==y) return x;
    for(int i=20;i>=0;i--){
        if(f[x][i]!=f[y][i]){
            x=f[x][i];
            y=f[y][i];
        }
    }
    return f[x][0];
}

int main(){
    init();
    cin>>n>>m>>root;
    for(int i=1;i<n;i++){
        int a,b;
        cin>>a>>b;
        add(a,b);//恶臭数据点不会考虑顺序的死活的
        add(b,a);
    }
    dfs(root,0);//从根节点开始预处理。
    for(int i=1;i<=m;i++){
        int a,b;
        cin>>a>>b;
        cout<<lca(a,b)<<endl;
    }
    return 0;
}

绷不住了。