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

前言：之后会用一个例题来说明LCA模板，并会总的分析一下此题的思路，会在代码中进行详细的注释。

题目： 

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

题源：https://www.luogu.org/problem/P3379

题目描述

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

输入格式

第一行包含三个正整数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

说明/提示

时空限制：1000ms,128M

数据规模：

对于30%的数据：N<=10，M<=10

对于70%的数据：N<=10000，M<=10000

对于100%的数据：N<=500000，M<=500000

样例说明：

该树结构如下：

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

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

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

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

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

故输出依次为4、4、1、4、4。

题解：

算法：倍增算法

解题思路： 
 一、将关系存入邻接表
 二、深搜。参数为根节点和假想根节点的父节点为0；
     1、利用dfs求每个节点的深度depth[i]；
     2、在dfs里求一下i的2^j的祖先结点，保存到f[i][j]数组中。
     3、遍历u的子节点，如果不是u的父亲的话，重复dfs。
 二、lca函数
 1、先让两个节点在统一深度
保证深度大的在前，小的在后。可以利用swap函数交换两个节点a，b的位置（不影响结果）。 然后让深度大的慢慢往上爬，直到爬到一样的深度。
 2、找他们的最近公共祖先
 这时候，如果a和b相等的话，说明a和b在一条子树上，没有在左右子树上，a和b的最近公共祖先是a。
 如果a和b不相等的话，这时候开始从上往下倍增查询。直到向下查询到第一个不相等的点，就是最近公共祖先的儿子。这第一个不相等的点的父亲就是最近公共祖先，返回最近公共祖先。

#pragma GCC optimize(2) //02优化
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
const int N = 1e6 + 10;

vector<int> ve[N];
int depth[N]; //存每个节点的深度
int f[N][30]; //f[i][j]表示第i个节点的2^j的节点
ll pow2[30]; //预存2的i次方

void POW2() //预先把2的多少次方计算出来
{
    pow2[0] = 1;
    for(int i = 1; i <= 29; i ++ ) pow2[i] = 2 * pow2[i - 1];
}

void dfs(int u, int fa)//起始节点fa是0，这时他的深度为0（其实这个0是另外加上的根节点）
{                      //u:当前节点 fa：u的父亲节点 
    depth[u] = depth[fa] + 1;
    f[u][0] = fa;
    
    for(int i = 1; i <= 29; i ++ ) f[u][i] = f[f[u][i - 1]][i - 1];
    //计算第i个节点的第2^j个祖先节点，因为f[u][0]上面已经有了，所以此处从1开始
    for(int i = 0; i <(int) ve[u].size(); i ++ )
    {
        int t = ve[u][i];
        
        if(t == fa) continue; //因为是用邻接表存的图，两个点正向反向连接的都有，所以此处要跳过父亲结点
                            //题目给出了根节点，这就可以判断哪个是父亲节点，哪个是子节点
        
        dfs(t, u); //继续由新的节点入手，求各节点的深度和i的第2^j个祖先节点
    }
}

int lca(int a, int b)
{
    if(depth[a] < depth[b]) swap(a, b);//保证深度大的在前，小的在后
    
    int dif = depth[a] - depth[b];//深度差
    
    for(int i = 29; i >= 0; i -- )
    {
    	if(pow2[i] <= dif)//在不超出深度差的范围向上爬
    	{
    		a = f[a][i]; //先前节点等于爬到位置的节点 
    		dif -= pow2[i];//深度差更新
		}
	}//执行完循环a,b已经是相同的深度
    
    if(a == b) return a;
    
    for(int i = 29; i >= 0; i -- )
    {
        if(f[a][i] != f[b][i] && pow2[i] <= depth[a])//pow2[i]<=depth[a]：表示不跳出树之外
        {
            a = f[a][i], b = f[b][i];
        }
    }
    
    return f[a][0];//返回lca的儿子的父亲，也就是lca 
}

int main()
{
//	freopen("input.txt", "r",stdin); 注释！注释！注释！！！ 
	
	POW2(); //这儿注意一定要执行下函数

    int n, m, s;
    int u, v;
    
    cin >> n >> m >> s;
    
    for(int i = 0; i < n - 1; i ++ )
    {
        scanf("%d %d", &u, &v);
        
        ve[u].push_back(v);
        ve[v].push_back(u); //存入邻接表
    }
    
    dfs(s, 0); //传入根节点和假想的根节点的父亲0
    
    for(int i = 0; i < m; i ++ )
    {
        scanf("%d %d", &u, &v);
        printf("%d\n", lca(u, v));
    }
    
    return 0;
}

这里附上同学的LCA思路：

1、 在线算法——倍增法。Depth[i]表示第 i 个节点的深度，我们设 根节点的深度为1；fa[i][j]表示第i个节点的第2^j 个祖先节点，则我们可以得出结论: i 的第2^j 个祖先节点 = i 的第2^(j-1)个祖先节点的第2^(j-1)个祖先节点 ，即 fa[i][j] = fa[ fa[i][j-1] ][j-1]。这样我们就可以以O(NlogN)预处理出每个节点的2^j 的祖先节点。

2、求a 和 b 的最近公共祖先节点的大致思路:

先判断u 的深度是否 小于 v 的深度，是的话，就交换一下，以保证 u 的深度 始终 大于 v的深度，方便后面的计算。当把 u 调到 与 v 同深度的时候，同时往上移动 u 和v，当调到一个最小的 j 满足

fa[u][j] != fa[v][j]时，最后再把 u 和 v 同时往上调一步，则下一个父节点就是所要求的最小公共祖先节点。

3、倍增法求最小公共祖先节点:

     首先用dfs求出每个节点的深度depth[i] 和 每个节点的第 2^j 个祖先节点fa[i][j];然后在通过lca()求u 和 v 的最小公共祖先节点，当调节 u(depth[u] > depth[v]) 的深度，使u 的深度等于 v 时，

我们再同时上调 u 和v 的深度。当 u 和v 调到离最小公共祖先节点最近的深度使fa[u][0] != fa[v][0],

那我们再同时上调一步得到的就是最小公共祖先节点了。