LCA - Lowest Common Ancestor（倍增求法）

倍增的思想是二进制。
首先开一个n×logn的数组，比如fa[n][logn],其中fa[i][j]表示i节点的第2^j个父亲是谁。

然后，我们会发现有这么一个性质：

                       fa[i][j]=fa[fa[i][j-1]][j-1]

用文字叙述为：i的第2^j个父亲 是i的第2^(j-1)个父亲的第2^(j-1)个父亲。

这是不是很神奇？这样，本来我们求i的第k个父亲的复杂度是O(k)，现在复杂度变成了O(logk)。

看上图理解

LCA(9,12) = 3

DFS预处理

我们可以通过一次dfs处理出fa数组：（dep[i]表示i的深度，这个可以一起处理出来，以后要用）

如果待处理的树有n个节点，那么最多有一个节点会有2^(logn)个父亲，所以我们的fa数组第二维开logn就够了。

这里用max0表示logn。初始化fa为0，若fa[i][j]=0表示i没有第2^j个父亲。

void dfs(int x){
    for(int i = 1;i <= max0;i++){
        fa[x][i]=fa[fa[x][i-1]][i-1];//i的第2^j个父亲 是i的第2^(j-1)个父亲的第2^(j-1)个父亲
    } 
    for(int i = 0; i < vec[x].size();i++){
    	int u = vec[x][i];
        if(u != fa[x][0]){     //如果u不是x的父亲就是x的儿子
            fa[u][0] = x;       //记录儿子的第一个父亲是x
            dep[u] = dep[x] + 1;      //处理深度
            dfs(u);
        }
    }
}

LCA求解

        倍增的应用中，最基础的应该就是求LCA(最近公共祖先)，时间复杂度是logn。

        对于求u、v的LCA，我们可以先把u、v用倍增法把深度大的提到和另一个深度相同。如果此时u、v已经相等了，表示原来u、v就在一条树链上，直接返回此时的结果。

        如果此时u、v深度相同但不等，则证明他们的lca在更“浅”的地方，此时需要把u、v一起用倍增法上提到他们的父亲相等。为啥是提到父亲相等呢？因为倍增法是一次上提很多，所以有可能提“过”了，如果是判断他们本身作为循环终止条件，就无法判断是否提得过多了，所以要判断他们父亲是否相等。详见代码：

int LCA(int u,int v){
    if(dep[u] < dep[v]) swap(u,v);  //我们默认u的深度一开始大于v，那么如果u的深度小就交换u和v
    int delta = dep[u] - dep[v];    //计算深度差
    for(int x = 0;x <= max0;x++){    //此循环用于提到深度相同。x从0或者max0开始都可以 
        if((1 << x) & delta)//因为我们要将u往上提delta个深度，所以将delta分解成二进制后，找到是1的位就向上提2^x个深度，这样最后一定提了delta个位 
            u = fa[u][x];
    }
    if(u == v) return u;//深度相同而且相等，表示原来u、v就在一条树链上，直接返回此时的结果 
    for(int x = max0;x >= 0;x--)     //注意！此处循环必须是从大到小!因为我们应该越提越“精确”，
        if(fa[u][x] != fa[v][x]){   //如果从小到大的话就有可能无法提到正确位置，自己可以多想一下
			u = fa[u][x];
            v = fa[v][x];
        }
    return fa[u][0];    //此时u、v的第一个父亲就是LCA。
}

以上就是倍增的主体思想，下面来一道模板式的例题

SP14932 LCA - Lowest Common Ancestor

直接上代码：

#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<cmath>
using namespace std;
int max0;//指数范围 
vector<int> vec[1005]; 
int fa[1005][11], dep[1005]; 
void dfs(int x){
    for(int i = 1;i <= max0;i++){
        fa[x][i]=fa[fa[x][i-1]][i-1];//i的第2^j个父亲 是i的第2^(j-1)个父亲的第2^(j-1)个父亲
    } 
    for(int i = 0; i < vec[x].size();i++){
    	int u = vec[x][i];
        if(u != fa[x][0]){     //如果u不是x的父亲就是x的儿子
            fa[u][0] = x;       //记录儿子的第一个父亲是x
            dep[u] = dep[x] + 1;      //处理深度
            dfs(u);
        }
    }
}
int LCA(int u,int v){
    if(dep[u] < dep[v]) swap(u,v);  //我们默认u的深度一开始大于v，那么如果u的深度小就交换u和v
    int delta = dep[u] - dep[v];    //计算深度差
    for(int x = 0;x <= max0;x++){    //此循环用于提到深度相同。x从0或者max0开始都可以 
        if((1 << x) & delta)//因为我们要将u往上提delta个深度，所以将delta分解成二进制后，找到是1的位就向上提2^x个深度，这样最后一定提了delta个位 
            u = fa[u][x];
    }
    if(u == v) return u;//深度相同而且相等，表示原来u、v就在一条树链上，直接返回此时的结果 
    for(int x = max0;x >= 0;x--)     //注意！此处循环必须是从大到小!因为我们应该越提越“精确”，
        if(fa[u][x] != fa[v][x]){   //如果从小到大的话就有可能无法提到正确位置，自己可以多想一下
			u = fa[u][x];
            v = fa[v][x];
        }
    return fa[u][0];    //此时u、v的第一个父亲就是LCA。
}
int main(){
	int T,n,cnt = 0;
	cin >> T;
	while(T--){
		memset(fa,0,sizeof fa);
		memset(dep,0,sizeof dep);
		for(int i = 0; i < 1005; i++){
			vec[i].clear();
		}
		scanf("%d",&n);
		max0 = log2(n);
		for(int i = 1; i <= n; i++){
			int num;
			scanf("%d",&num);
			for(int j = 0; j < num;j++){
				int a;
				scanf("%d",&a);
				vec[i].push_back(a);
				vec[a].push_back(i);
			}
		}
		dfs(1);
		int q;
		cnt++;
		printf("Case %d:\n", cnt);
		scanf("%d%",&q);
		while(q--){
			int x,y;
			scanf("%d%d",&x,&y);
			printf("%d\n",LCA(x,y));
		} 
	}
	return 0;
} 

注：本篇文章讲解部分来自：https://blog.csdn.net/Saramanda/article/details/54963914