最近公共祖先：LAC

一、概念

1.LAC问题：最近公共祖先问题，指给你一棵有根树和结点u、v，在树上找一个结点是u和v的共同祖先，并且深度尽可能大，也就是这个点尽可能远离树根，接近u、v。

二、方法

暴力枚举，倍增法，tarjan解法，RMQ等。

1.暴力枚举

已知一棵有根树根为T，先遍历一遍所有结点，找到每个结点的父亲，因为树的每一个结点只有一个父结点，先对u进行回溯，就是一直向上找父结点，直到回溯到根结点，把回溯到的结点都标记上，再对v进行回溯，直到找到第一个共同标记点，即u和v的最近公共祖先。
代码如下，前提是知道根结点：

#include<bits/stdc++.h>
using namespace std;
const int N=100000;
struct edge
{
    int to,next;
} t[2*N];
int h[2*N],p=1,n,m,s,fa[2*N],bj[2*N],b[2*N];
void add(int u,int v)
{
    t[p].to=v;
    t[p].next=h[u];
    h[u]=p++;
}//链式前向星建图
void dfs(int x)//从x开始向下搜索
{
    for(int i=h[x]; i; i=t[i].next)
    {
        if(!b[t[i].to])//用数组b记录该结点有没有当过父结点
        {
            b[t[i].to]=1;//标记已经查过了
            fa[t[i].to]=x;//x为t[i].to的父结点
            dfs(t[i].to);//继续找t[i].to的父结点
        }
    }
}
int main()
{
    cin>>n>>m>>s;//n表示结点个数,m表示查寻次数，s表示根结点
    int x,y;
    for(int i=1; i<n; i++)
    {
        cin>>x>>y;
        add(x,y),add(y,x);
    }//建图,已知x和y是相邻结点
    b[s]=1;
    dfs(s);//从根结点开始标记好各个点的父结点
    for(int i=1; i<=m; i++)
    {
        memset(bj,0,sizeof(bj));//每次查询都需要重置bj数组
        cin>>x>>y;
        bj[x]=1;
        for(int i=fa[x]; i; i=fa[i])
            bj[i]=1;
        if(bj[y])
        {
            cout<<y<<endl;
            continue;
        }
        for(int i=fa[y]; i; i=fa[i])
            if(bj[i])
            {
                cout<<i<<endl;
                break;
            }
    }
    return 0;
}

举个例子：

如图：8与9的最近公共祖先是5，6和7的最近公共祖先是3，5和6的最近公共祖先是1。

2.倍增法

说倍增法前，先说另一种方法，与暴力枚举法类似。我们知道，两个结点的共同祖先一定在树的同一深度，所以我们可以先从深度较大的结点u向上找，找到u的一个祖先s与结点v在同一深度，判断s与v是否相等，若相等就是s结点，若不等就s和v一起向上找，保证s和v始终在同一深度，直到两个结点是同一个结点为止。画个图便于理解：

上图发现10和9的最近共同祖先是5，我们先把深度更深的10跳到8，这样就和9在同一深度了，然后在8和9位置一起向上跳，先跳的远一点，一般跳到根结点，这时两个位置跳到的结点一定是一样的，即相交，依次再跳的近一点，直到找到第一个不相交的位置，这个位置的父结点就是LAC。
但是这样一步一步地跳近一点会很浪费时间，倍增法就是对上面过程的优化。当u和v深度不同时（假设u更深）,我们先把u向上跳到与v同一深度的祖先s处，我们知道任何数都可以拆分成若干个2的幂之和的形式，我们对处在同一深度的s和v一起假向上跳2^x步（假跳就是看看跳到哪里了，但不改变现在所在的位置），一开始都假跳到根结点，即相交了，我们调小幂2^x-1继续假跳，直到跳到不相交处，这时真跳到不相交的两个位置，继续调小幂假跳，重复以上过程，直到跳到2⁰=1步为止，这时u或者v跳到的结点的父结点就是他们的最近公共祖先，也就是跳的过程中u,v两条支路最后一个相交的点。
代码实现：用到了ST算法，我们用数组DP[i] [j]表示结点i向上2^j层组先。

上图中DP[10][1]=5，结点10的向上2¹=2层祖先是结点5；
DP[5][0]=2，结点5的向上2⁰=1层祖先是2，即父结点。
所以有如下递推式，DP[i][j]=DP[DP[i][j-1]][j-1]，也就是i结点的2^j层祖先等于2^j-1层祖先的2^j-1层祖先，因为2^j=2^j-1+2^j-1。

#include<bits/stdc++.h>
using namespace std;
#define N 100000+5
int n,q;
int p=1,h[N];
int dp[N][20],dep[N];
struct edge
{
    int to,next;
}t[2*N];
void add(int u,int v)
{
	t[++p].to=v;
	t[p].next=h[u];
	h[u]=p;
}
void dfs(int root,int pre)//初始化，先建好所有的DP关系
{
    dep[root]=dep[pre]+1;//root的深度等于父结点的深度加1，pre是root的父结点。
    dp[root][0]=pre;
    for(int i=1;(1<<i)<=dep[root];i++)
    {
        dp[root][i]=dp[dp[root][i-1]][i-1];
    }
    for(int i=h[root];i;i=t[i].next)
    {
        if(t[i].to!=pre)
            dfs(t[i].to,root);
    }
}
int LCA(int x,int y)
{
	if(dep[x]<dep[y]) swap(x,y);//让x的深度大
	for(int i=19; i>=0; i--)
	{
		if(dep[x]-(1<<i)>=dep[y])//往上跳深度在减少
        {
            x=dp[x][i];//跳到同一个点
        }
		if(x==y) return x;//位置相同，X就是LCA
	}
	for(int i=19; i>=0; i--)
		if(dp[x][i]!=dp[y][i]) x=dp[x][i],y=dp[y][i];//倍增跳，找不相交的位置，然后跳到那个位置
	return dp[x][0];//或dp[y][0]，即第一个不相交的位置的父亲是LCA
}
int main()
{
	int x,y;
	cin>>n;
	for(int i=1; i<n; i++)
	{
	    cin>>x>>y;
		add(x,y),add(y,x);
	}
	dfs(1,1);
	cin>>q;
	for(int i=1; i<=q; i++)
	{
		cin>>x>>y;
		cout<<LCA(x,y)<<endl;//输出x与y的最近公共祖先
		cout<<dep[x]+dep[y]-2*dep[LCA(x,y)]<<endl;
		//输出x到y的距离：是x的深度+y的深度-2*LCA的深度。
		//cout<<(dep[x]-dep[LCA(x,y)])*2+dep[y]-dep[LCA(x,y)]<<endl;
	}
	return 0;
}

---

未完。。。