LCA

LCA作为树上的一种重要操作，在许多算法(如树链剖分)中作为不可或缺的基础操作，是必须掌握的内容之一。其思想是很简单的。若求LCA的两点在同一条链上，那么它们的LCA就是深度较浅的那个点；若两点分别在两棵子树上，我们就需要先保证两点深度相同，再同时向上溯源，当溯源路径相交时，它们的LCA就是路径的交点。为了加速这个“向上溯源”的过程，我们可以使用倍增算法进行加速。

其代码实现主要分为两个部分：DFS和LCA。

DFS部分需要求出每个节点的深度和父节点，以及在不超出根节点的情况下求出$2^i$级父节点；
LCA部分就是上面所讲到的“调整深度”的部分。

代码如下：

#include
using namespace std;
const int maxn=1e6+5;
int n,m,s,x,y,a,b;
int d[maxn],f[maxn][20];
int head[maxn],ecnt=1;
void swap(int &a,int &b)
{
	int c=a;
	a=b;
	b=c;
}
struct list{
	int r,n;
}l[maxn]; 
void add(int x,int y)
{
	l[ecnt].r=y;
	l[ecnt].n=head[x];
	head[x]=ecnt++;
}
void dfs(int k,int fa)
{
	d[k]=d[fa]+1;//深度为父节点+1
	f[k][0]=fa;//标记父节点
	for(int i=1;(1<<i)<=d[k];i++)//"(1<
		f[k][i]=f[f[k][i-1]][i-1];//求2^i级父节点
		//子节点的2^i级父节点为子节点的2^(i-1)级父节点的2^(i-1)级父节点，相当于2^i=2^(i-1)+2^(i-1)
	for(int j=head[k];j;j=l[j].n)
		if(l[j].r!=fa) dfs(l[j].r,k);//遍历子节点，找到父节点就跳过
}
int lca(int p,int q)
{
	if(d[p]<d[q]) swap(p,q);//在lca时，我们总是令深度更大的一个点为p，方便操作
	for(int i=19;i>=0;i--)
		if(d[f[p][i]]&&d[f[p][i]]>=d[q]) p=f[p][i];//在保证p的深度不小于q的前提下尽可能把p的深度减小
	if(p==q) return p;
	//如果两点在同一链上，最后一定有p==q,直接return即可;
	//如果两点分别在两棵子树上，最后一定有两点深度相等
	for(int i=19;i>=0;i--)
	{
		if(d[f[p][i]]&&f[p][i]!=f[q][i])
		//由于两点深度相同，则某一点的2^i级祖先存在时，另一点的2^i级祖先也一定存在
		//如果两点分别在两棵子树上，则在2^i级祖先存在且两点的2^i级祖先不等时同时将p,q两点溯源2^i级
		{
			p=f[p][i];
			q=f[q][i];
		}
	}
	return f[p][0];//上述操作在两点的2^0级父节点相等时停止，这时直接返回父节点即可
}
int main()
{
	scanf("%d%d%d",&n,&m,&s);
	for(int i=1;i<n;i++)
	{
		scanf("%d%d",&x,&y);
		add(x,y);
		add(y,x); 
	}
	dfs(s,0);
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d",&x,&y);
		printf("%d\n",lca(x,y));
	}
	return 0;
}

关于“一定”的解释：由二进制的特点可知，十进制的每个数都可以拆成${\sum }_{i=1}^{n}a\ast 2^i(a=0或a=1)$的形式，所以对于任意需要溯源的级数，对其二进制组成(即上面提到的和式)进行遍历，一定可以得到这个数。