LCA——最近公共祖先

今天终于把倍增的LCA搞懂了！尽管周测都没写，尽管lca其实很简单，但这也是进度君的往前一点点的快乐。学渣的呻吟。

倍增的lca其实关键就在于二进制的二进制的拆分（显然是两次的拆分，很奇妙，懂二进制的自然不觉得什么）。把最关键的地方在这里列举一下吧：

1.f[fa][i]=f[f[fa][i-1]][i-1];类似于状态转移，i表示2^i可以表示fa的2的i次方的祖先所以当前的fa的2^i的祖先就是它2-1次方的祖先的2-1次方的祖先

想要理解为什么是这样，1+1=2；2+2=4；4+4=8；8+8=16；故2^i-1+2^i-1=2^i；到这里就可以理解了吧。

2.for(int i=t;i>=0;i--) 这里的t是t=(int)(log(n)/log(2))+1;的出来的n是最大的数目也就是log数，if(depth[f[y][i]]>=depth[x]) y=f[y][i];这里的是指假如当前的深度和x的深度比，能调到和x一样深就跳，这个代码完成了将y跳到x，二进制的拆分就是如此神奇！！！。（dalao勿喷蒟蒻没见过二进制拆分）

3.for(int i=t;i>=0;i--) if(f[x][i]!=f[y][i]) x=f[x][i],y=f[y][i];这里的也就是x，y虽然到了同样的深度但是呢，公共祖先还是没有出来所以可以进行同时向上爬（我要一步一步向上爬）因为二进制的拆分所以最后都会达到距离最近公共祖先最近的子节点处，所以最后输出x的父亲节点就是x，y的公共子节点了，二进制的拆分就是如此神奇！！！。（dalao勿喷蒟蒻没见过二进制拆分）

这就是lca的具体之处认真思考其实都很简单（无奈作业太多）多思考啊。

复杂度为 O((n+m)logn)原因预处理处。

代码：

#include<iostream>
#include<iomanip>
#include<cstdio>
#include<ctime>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<string>
#include<queue>
#include<vector>
#include<map>
using namespace std;
inline int read()
{
    int x=,f=;char ch=getchar();
    while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
    return x*f;
}
const int maxn=<<;
const int maxx=;
int n,m,s,t;
int lin[maxn],nex[maxn],ver[maxn],len=;
int depth[maxx],f[maxx][];
void add(int x,int y)
{
    ver[++len]=y;
    nex[len]=lin[x];
    lin[x]=len;
}
void dfs(int fa,int fath)
{
    depth[fa]=depth[fath]+;
    f[fa][]=fath;
    for(int i=;i<=t;i++)
        f[fa][i]=f[f[fa][i-]][i-];
    for(int i=lin[fa];i;i=nex[i])
        if(ver[i]!=fath)
            dfs(ver[i],fa);
}
int lca(int x,int y)
{
    if(depth[x]>depth[y])
        swap(x,y);
    for(int i=t;i>=;i--)
        if(depth[f[y][i]]>=depth[x])
            y=f[y][i];
    if(x==y)
        return x;
    for(int i=t;i>=;i--)
        if(f[x][i]!=f[y][i])
            x=f[x][i],y=f[y][i];
    return f[x][];
}
int main()
{
    //freopen("1.in","r",stdin);
    n=read();m=read();s=read();
    t=(int)(log(n)/log())+;
    for(int i=;i<n;i++)
    {
        int x,y;
        x=read();y=read();
        add(x,y);add(y,x);

    }
    dfs(s,);
    for(int i=;i<=m;i++)
    {
        int x,y;
        x=read();y=read();
        printf("%d\n",lca(x,y));
    }
    return ;
}

学长说求lca 方法有：倍增（如上），tanjan（如下），st（不懂），树剖（不会）。

那就浅谈tanjan离线来求lca吧。主要运用并查集的回溯的神奇效应，很好懂得。

当前当前节点回溯时查询问题点是否回溯过，一旦回溯过就有父亲了。没有的话让另一个对应点来更新具体细节看代码。

#include<bits/stdc++.h>
#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cstring>
#include<string>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<queue>
#include<deque>
#include<vector>
#include<map>
#include<stack>
#include<set>
#include<bitset>
using namespace std;
inline int read()
{
    int x=,f=;char ch=getchar();
    while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
    return x*f;
}
inline void put(int x)
{
    if(x==){putchar('');putchar('\n');return;}
    if(x<)putchar('\n'),x=-x;
    int num=;char ch[];
    while(x)ch[++num]=x%+'',x/=;
    while(num)putchar(ch[num--]);
    putchar('\n');return;
}
const int maxn=;
vector<int>q[maxn],q1[maxn];
int n,m,s;
int f[maxn],vis[maxn],ans[maxn];//存答案
int ver[maxn<<],nex[maxn<<],lin[maxn<<],len=;
void add(int x,int y)
{
    ver[++len]=y;
    nex[len]=lin[x];
    lin[x]=len;
}
int getfather(int x){return f[x]==x?x:f[x]=getfather(f[x]);}
void tarjan(int x)
{
    vis[x]=;
    for(int i=lin[x];i;i=nex[i])
    {
        int tn=ver[i];
        if(vis[tn]!=)continue;//防止便利到父亲啊
        //等价于 if(vis[tn]==1)continue;因为儿子没回溯父亲也不可能回溯
        tarjan(tn);
        f[tn]=x;
        vis[tn]=;//直接标记回溯过了
    }
    for(int i=;i<q[x].size();i++)
    {
        int tn=q[x][i];
        if(vis[tn]==)//如果对应点回溯过那么父亲就有了！
        {
            ans[q1[x][i]]=getfather(tn);
        }
    }
    //vis[x]=2;这里标记回溯当然也是可以的啦
    //因为对x是否回溯对当前x节点的对应点询问和x是否回溯过无关所以可以进行上述面的标记

}
int main()
{
    //freopen("1.in","r",stdin);
    n=read();m=read();s=read();
    for(int i=;i<n;i++)
    {
        int x,y;
        x=read();y=read();
        add(x,y);add(y,x);
    }
    for(int i=;i<=n;i++)f[i]=i;
    for(int i=;i<=m;i++)
    {
        int x,y;
        x=read();y=read();
        q[x].push_back(y);q[y].push_back(x);
        q1[x].push_back(i);q1[y].push_back(i);//为了O(n)输出答案而准备
    }
    tarjan(s);
    for(int i=;i<=m;i++)put(ans[i]);
    return ;
}

复杂度 O(n+2*m)-->O(n+m);

高歌取醉欲自慰，起舞落日争光辉。