LCA 最近公共祖先

Tarjan(离线)算法的基本思路及其算法实现

　　　　首先是最近公共祖先的概念(什么是最近公共祖先？)：

　　　　在一棵没有环的树上，每个节点肯定有其父亲节点和祖先节点，而最近公共祖先，就是两个节点在这棵树上深度最大的公共的祖先节点。

　　　　换句话说，就是两个点在这棵树上距离最近的公共祖先节点。

　　　　所以LCA主要是用来处理当两个点仅有唯一一条确定的最短路径时的路径。

　　　　有人可能会问：那他本身或者其父亲节点是否可以作为祖先节点呢？

　　　　答案是肯定的，很简单，按照人的亲戚观念来说，你的父亲也是你的祖先，而LCA还可以将自己视为祖先节点。

　　　　举个例子吧，如下图所示４和５的最近公共祖先是２，５和３的最近公共祖先是１，２和１的最近公共祖先是１。　

　　　　这就是最近公共祖先的基本概念了，那么我们该如何去求这个最近公共祖先呢？

　　　　通常初学者都会想到最简单粗暴的一个办法：对于每个询问，遍历所有的点，时间复杂度为O(n*q)，很明显，n和q一般不会很小。

　　　　常用的求LCA的算法有：Tarjan/DFS+ST/倍增

　　　　后两个算法都是在线算法，也很相似，时间复杂度在O(logn)~O(nlogn)之间，我个人认为较难理解。

　　　　有的题目是可以用线段树来做的，但是其代码量很大，时间复杂度也偏高，在O(n)~O(nlogn)之间，优点在于也是简单粗暴。

　　　　这篇博客主要是要介绍一下Tarjan算法(其实是我不会在线...)。

　　　　什么是Tarjan(离线)算法呢？顾名思义，就是在一次遍历中把所有询问一次性解决，所以其时间复杂度是O(n+q)。

　　　　Tarjan算法的优点在于相对稳定，时间复杂度也比较居中，也很容易理解。

　　　　下面详细介绍一下Tarjan算法的基本思路：

　　　　　　1.任选一个点为根节点，从根节点开始。

　　　　　　2.遍历该点u所有子节点v，并标记这些子节点v已被访问过。

　　　　　　3.若是v还有子节点，返回2，否则下一步。

　　　　　　4.合并v到u上。

　　　　　　5.寻找与当前点u有询问关系的点v。

　　　　　　6.若是v已经被访问过了，则可以确认u和v的最近公共祖先为v被合并到的父亲节点a。

　　　　遍历的话需要用到dfs来遍历(我相信来看的人都懂吧...)，至于合并，最优化的方式就是利用并查集来合并两个节点。

　　　　下面上伪代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn=4e4+100;
const int maxm=220;
int d[maxn];//d[u]表示u结点距根的距离

struct edge
{
    int from,to,w,next,lca;
}e[maxn<<1],q[maxm<<1];
int par[maxn],n;
int ance[maxn];
int head[maxn],cnt,first[maxn],tot,vis[maxn];
void add_edge(int u,int v,int w)//树图连边
{
    e[++cnt].to=v;
    e[cnt].w=w;
    e[cnt].next=head[u];
    
    head[u]=cnt;
}
void _add(int u,int v)//查询连边，都是单向边
{
    q[++tot].to=v;
    q[tot].from=u;

    q[tot].next=first[u];
    first[u]=tot;
}
void init()//边以及并查集的初始化
{
    memset(head,-1,sizeof(head));
    memset(first,-1,sizeof(first));
    memset(vis,0,sizeof(vis));
    for(int i=0;i<=n;i++) par[i]=i;
    tot=-1;//查询边的编号从0开始
    cnt=-1;//树图边的编号从0开始
}
int find(int x)//查询祖先结点
{
    return par[x]==x?x:par[x]=find(par[x]);
}

void unit(int x,int y)//合并
{
    int fx=find(x),fy=find(y);
    if(fx==fy) return ;
    par[fx]=fy;
}
void tarjan(int u)//dfs+并查集
{
    vis[u]=1;//标记已访问
    for(int i=head[u];i!=-1;i=e[i].next)
    {
        int v=e[i].to;
        if(vis[v]) continue;
        d[v]=d[u]+e[i].w;//在dfs的同时维护d
        tarjan(v);//将v子树dfs完
        unit(v,u);//合并v子树到u结点
    }
    for(int i=first[u];i!=-1;i=q[i].next)
    {
        int v=q[i].to;
        if(!vis[v]) continue;
        q[i].lca=q[i^1].lca=find(v);
    }
}
int main()
{
    int T,m;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        init();
        for(int i=1;i<n;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);
            add_edge(v,u,w);
        }
        for(int i=1;i<=m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            _add(u,v);
            _add(v,u);
        }
        d[1]=0;
        tarjan(1);
        for(int i=0;i<m;i++)
            
        {
            int id=i*2,u=q[id].from,v=q[id].to,lca=q[id].lca;
            printf("%d\n",d[u]+d[v]-2*d[lca]);
        }
    }
    return 0;
}

有一点要注意的是：查询边的时候一定是双向边，因为如果是单向边的话，左子树要指向右子树点的时候，你右子树没有遍历过，所以那个值没有写入，但是当你遍历完右子树的时候，右子树上就没有这一条查询边了，所以要求查询边必须要双向边。然后就是建树边了。因为你不能知道是把哪一个顶点作为根节点，所以你必须要使用双向边。你在dfs的时候就顺手维护每一个节点到根节点的距离。然后经过推理可以得出。两个顶点的最短距离是两个顶点到最近公共祖先的距离。这个距离就是两个顶点到根节点的距离之和-2* 最近公共祖先到根节点的距离

tarjin函数的思路：

1.首先他tarjin（1）那么往2下面走。

2.节点2tarjin（2），往4走。

3.节点4tarjin（4），往6走。

4.6没有继续往下的节点。所以查询边6 8但是8没有被走过（凡是走过的顶点都要vis数组标记为1）

5.合并顶点6 4 2，所以此时4 6的父亲节点为2.2往右走以此类推。走到8节点时候。查询边可以得到6已经走过，所以就是find【6】。