每日算法——新型在线LCA

在线LCA一般大家都会用倍增吧，时间复杂度O(nlogn)，空间复杂度O(nlogn)，都是非常严格的复杂度限制，并且各种边界处理比较麻烦，有没有更快更好的办法呢？

我们发现，在树链剖分时，我们不经意的找到了LCA，能不能用这种方法找LCA呢？

答案是肯定的，使用轻重链剖分达到的LCA，时间复杂度最坏为O(logn)，预处理是O(n)的dfs，比起每次处理严格O(nlogn)，预处理O(nlogn)的倍增看起来好了很多，下面我们就用实验测量一下。

使用一个随机数据生成器生成了99组100000个点100000次询问的LCA，测试结果如下：

测试环境：intel I5-4200M 2.5GHz*2 windows7 VMware虚拟机

测试软件：cena 0.8

测试结果：

可以看到，树链剖分的代码比倍增有明显的优势，但是优势并不是特别大，平均每个点快了0.1秒左右。没有快太多的原因还是因为常数较大，劣处是代码量大了大约三十行。事实上，本人认为树链剖分比较好想，边界容易。

代码：

倍增：by Ommy_Zhang

 #include <cstdio>
 #include <iostream>
 #include <cstring>
 #include <algorithm>
 using namespace std;
 #define MAXN 101010
 #define MAXM 202020
 #define TC 2000000
 int n,m,u,v,k,lca,lastans;
 int head[MAXN],next[MAXM],go[MAXM],cnt;
 int father[MAXN][],deep[MAXN];

 void add(int a,int b)
 {
     go[++cnt]=b;
     next[cnt]=head[a];
     head[a]=cnt;
 }
 void dfs(int x)
 {
     for(int k=;father[x][k];++k)
         father[x][k+]=father[ father[x][k] ][k];
     for(int e=head[x];e;e=next[e])
         if(go[e]!=father[x][])
         {
             deep[go[e]]=deep[x]+;
             father[go[e]][]=x;
             dfs(go[e]);
         }
 }
 int get_lca(int a,int b)
 {
     if(deep[a] < deep[b])
     {
         int t=a;
         a=b;
         b=t;
     }
     int d=deep[a]-deep[b];
     for(int k=;k<;++k)
         if((d>>k)&)
             a=father[a][k];
     if(a==b)  return a;

     for(int k=;k>=;--k)
         if(father[a][k]!=father[b][k])
         {
             a=father[a][k];
             b=father[b][k];
         }
     return father[a][];

 }
 int main()
 {
     freopen ("LCA.in","r",stdin);
     freopen ("LCA.out","w",stdout);
     int n;
     scanf("%d",&n);
     int j,k;
     for (int i=;i<n;++i)
     {
         scanf("%d%d",&j,&k);
         add(j,k);
         add(k,j);
     }
     dfs();
     int m;
     scanf("%d",&m);
     for (int i=;i<=m;++i)
     {
         scanf("%d%d",&j,&k);
         printf("%d\n",get_lca(j,k));
     }
     return ;
 }

树链剖分：by SymenYang

#include <iostream>
#include <cstdio>
#include <algorithm>
#define maxn 100010
using namespace std;
struct edge
{
    int to;
    edge* next;
}ed[];

edge* head[];
int cnt=-;
void add(int j,int k)
{
    edge* q=&ed[++cnt];
    q->to=k;
    q->next=head[j];
    head[j]=q;
}
int fa[maxn];
int top[maxn];
int dep[maxn];
edge* wei[maxn];
int size[maxn];
void dfs(int now,int de,int last)
{
    dep[now]=de;
    size[now]=;
    fa[now]=last;
    int maxx=;
    for (edge* q=head[now];q!=NULL;q=q->next)
    {
        if (q->to!=last)
        {
            dfs(q->to,de+,now);
            if (size[q->to]>maxx)
            {
                wei[now]=q;
            }
            size[now]+=size[q->to];
        }
    }
    return;
}

void dfs2(int now,int last,int to)
{
    top[now]=to;
    if (wei[now])
        dfs2(wei[now]->to,now,to);
    for (edge* q=head[now];q!=NULL;q=q->next)
    {
        if (q->to!=last&&q!=wei[now])
        {
            dfs2(q->to,now,q->to);
        }
    }
    return;
}

int get_lca(int a,int b)
{
    while (top[a]!=top[b])
    {
        if (dep[top[a]]<dep[top[b]]) a^=b^=a^=b;
        a=fa[top[a]];
    }
    return dep[a]<dep[b]? a:b;
}

int main()
{
    freopen ("LCA.in","r",stdin);
    freopen ("LCA.out","w",stdout);
    int n;
    scanf("%d",&n);
    int j,k;
    for (int i=;i<=n;++i) head[i]=NULL;
    for (int i=;i<n;++i)
    {
        scanf("%d%d",&j,&k);
        add(j,k);
        add(k,j);
    }
    dfs(,,);
    dfs2(,,);
    int m;
    scanf("%d",&m);
    for (int i=;i<=m;++i)
    {
        scanf("%d%d",&j,&k);
        printf("%d\n",get_lca(j,k));
    }
    return ;
}