一、Tarjan求LCA（离线）

       其实这个Tarjan与上一篇讲的四种没有一点联系，它只是Tarjan发明的而且恰好也叫Tarjan，上一篇讲的是求强连通分量的。而这一篇所讲的Tarjan实际上是一种离线算法。 

       下面讲一下Tarjan算法的基本思路：

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

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

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

       4.合并v到u上。

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

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

       用dfs来遍历，合并最优化的方式就是利用并查集来合并两个节点。

       例题​​POJ1330​​。模板题。

Code：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#define N 20005
using namespace std;
int head[N],flag[N],father[N],fa[N];
int totre,headre[N],a,b,tot,ancestor[N];
struct edge
{
  int vet,next;
}edge[N],require[N];
void add(int u,int v)
{
  edge[++tot].vet=v;
  edge[tot].next=head[u];
  head[u]=tot;
}
int getfather(int x)
{
  if(x==father[x])return x;
  return father[x]=getfather(father[x]);
}
void merge(int x,int y)
{
  x=getfather(x);
  y=getfather(y);
  if(x!=y)father[x]=y;
}
void tarjan(int u)
{
  for(int i=head[u];i!=-1;i=edge[i].next)
  {
    int v=edge[i].vet;
    tarjan(v);
    merge(u,v);
    ancestor[getfather(u)]=u;
  }
  flag[u]=true;
  for(int i=headre[u];i!=-1;i=require[i].next)
  {
    int v=require[i].vet;
    if(flag[v])
      printf("%d\n",ancestor[getfather(v)]);
  }
}
void addre(int u,int v)
{
  require[++totre].vet=v;
  require[totre].next=headre[u];
  headre[u]=totre;
}
int main()
{
  int T;
  scanf("%d",&T);
  while(T--)
  {
    memset(head,-1,sizeof(head));
    memset(headre,-1,sizeof(headre));
    tot=0,totre=0;int n;
    scanf("%d",&n);
    memset(fa,0,sizeof(fa));
    for(int i=1;i<n;i++)
    {
      int u,v;
      scanf("%d%d",&u,&v);
      add(u,v);
      fa[v]++;
    }
    int root;
    memset(flag,false,sizeof(flag));
    for(int i=1;i<=n;i++)
      if(fa[i]==0)root=i;
    scanf("%d%d",&a,&b);
    addre(a,b);addre(b,a);
    for(int i=1;i<=n;i++)
      father[i]=i;
    tarjan(root);
  }
  return 0;
}

二、树上倍增求LCA（在线）

 

       那么接下来看一下倍增算法。它可以在线求树上两个点的LCA。

       先通过dfs遍历，记录每个节点的深度deep[u]。

       再求出树上每个节点u的2^i祖先fa[u][i]。

       然后根据两个节点的的深度，如不同，向上调整深度大的节点，使得两个节点在同一层上，如果正好是祖先结束，否则，将连个节点同时上移，查询最近公共祖先。

       这个算法看看非常简单，它的时间复杂度为nlogn。

       依然以POJ1330为例。

Code:

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#define N 20005
using namespace std;
int head[N],a,b,tot,fa[N][21],f[N],deep[N];
inline int read()
{
  int x=0,f=1;char s=getchar();
  while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
  while(s<='9'&&s>='0'){x=x*10+s-'0';s=getchar();}
  return x*f;
}
struct edge
{
  int vet,next;
}edge[N];
void add(int u,int v)
{
  edge[++tot].vet=v;
  edge[tot].next=head[u];
  head[u]=tot;
}
void dfs(int u)
{
  for(int i=head[u];i!=-1;i=edge[i].next)
  {
    int v=edge[i].vet;
    if(v==fa[u][0])continue;
    deep[v]=deep[u]+1;
    fa[v][0]=u;
    dfs(v);
  }
}
int lca(int a,int b)
{
  if(deep[a]>deep[b])swap(a,b);
  int d=deep[b]-deep[a];
  for(int i=0;i<=20;i++)
    if((1<<i)&d)b=fa[b][i];
  if(a==b)return a;
  for(int i=20;i>=0;i--)
    if(fa[a][i]!=fa[b][i])
    {
      a=fa[a][i];
      b=fa[b][i];
    }
  return fa[a][0];
}
int main()
{
  int T;
  scanf("%d",&T);
  while(T--)
  {
    memset(head,-1,sizeof(head));
    memset(f,0,sizeof(f));
    memset(fa,0,sizeof(fa));
    memset(deep,0,sizeof(deep));
    tot=0;
    int n=read();
    for(int i=1;i<n;i++)
    {
      int u=read(),v=read();
      add(u,v);
      f[v]++;
    }
    int root;
    for(int i=1;i<=n;i++)
      if(f[i]==0)root=i;
    dfs(root);
    for(int j=1;j<=20;j++)
      for(int i=1;i<=n;i++)
        fa[i][j]=fa[fa[i][j-1]][j-1];
    int a=read(),b=read();
    printf("%d\n",lca(a,b));
  }
  return 0;
}