最近公共祖先
最近公共祖先(Lowest Common Ancestor),简称 LCA,是树论板块里最基础也是最受欢迎的一个板块,对于这个问题目前已经有无数种奇奇怪怪的解法了,今天我来说几种比较常用的求 LCA 的方法。
始于暴力
这个虽然不是我们最常用的,但是它可以带给我们很多启发。
具体的暴力怎么做呢?首先我们要求树上两点 \(x,y\) 的 LCA,那么我们先让它们的深度相同,因此可以先让深度更深的那个点一直跳,直到跳到跟 \(y\) 深度相同时停止。
然后就可以 \(x\) 和 \(y\) 一起同时跳了,如果当前的 \(x\) 与 \(y\) 相等那么直接返回即可,否则接着跳。
这个东西的复杂度显然最坏是树深度的,树深度最坏是 \(O(n)\) 的,所以复杂度最坏就是 \(O(n)\)。
代码:
int LCA(int x,int y)
{
if(depth[x]<depth[y])
{
swap(x,y);
}
while(depth[x]>depth[y])
{
x=fa[x];
}
while(x!=y)
{
x=fa[x],y=fa[y];
}
return x;
}
倍增求 LCA
上面的暴力其实已经告诉我们了一个思路,就是先让两个点移动到同一深度,再不断地跳,直到跳到相同节点就停下。
那我们有没有什么办法加速这个跳的过程呢?显然是有的。
我们可以将倍增的思想带进去:设 \(fa_{x,i}\) 表示 \(x\) 的第 \(2^i\) 级祖先,那么我们就可以做到 \(O(\log n)\) 的跳了。
代码:
int LCA(int x,int y)
{
if(depth[x]<depth[y])
{
swap(x,y);
}
for(int i=20;i>=0;i--)
{
if(depth[fa[x][i]]<=depth[y])
{
x=fa[x][i];
}
}
if(x==y)
{
return x;
}
for(int i=20;i>=0;i--)
{
if(fa[x][i]!=fa[y][i])
{
x=fa[x][i],y=fa[y][i];
}
}
return fa[x][0];
}
为啥要先跳到两个点不同的地方呢?这个也很好解释。显然你会发现在 LCA 上面的所有点都是相同的,也就是说如果 \(x\) 和 \(y\) 跨了一大步跳到了 LCA 上面,此时这两个点还是在同一个点上,那么就找不到 LCA 了。所以必须先找第一次不一样的地方。
欧拉序求 LCA
欧拉序求 LCA 是另一种比较常见的方法,它可以做到 \(O(n\log n)\) 预处理,\(O(1)\) 查询,所以在卡常时经常会用到它。
首先我们来说说欧拉序。欧拉序就是按照你 dfs 的顺序将经过的点一个一个的记录下来,重复经过也要重复记录。显然每条边只会被遍历两次,每次遍历会多增加一个点,而根节点在最开始会额外增加,所以总共记录的点数就是 \(2(n-1)+1=2n-1\)。
那欧拉序的特点在哪呢?它最大的一个特点就是说对于任意的两个点 \(x,y\),记 \(x\) 第一次出现的位置是 \(L_x\),\(y\) 最后一次出现的位置是 \(R_y\),那么你很容易观察到在区间 \([L_x,R_y]\) 中 \(x,y\) 的 LCA 绝对出现过并且 LCA 上面的点没有出现。为啥嘞?显然你要从 \(x\) 走到 \(y\) 就必须经过 \(x,y\) 的 LCA,而且对于 LCA 上面的点,因为 \(x,y\) 在同一子树内,所以中间并不会经过这些点。所以就得到了上面的结论。
那么我们很容易想到找出 \([L_x,R_y]\) 中深度最浅的那个点就是 LCA 了。而找深度最浅显然是一个 RMQ 问题,用 ST 表就可以解决。
代码:
int LCA(int x,int y)
{
int l=min(L[x],L[y]),r=max(R[x],R[y]);
int k=log2(r-l+1);
if(depth[st[l][k]]<depth[st[r-(1<<k)+1][k]])
{
return st[l][k];
}
else
{
return st[r-(1<<k)+1][k];
}
}
树剖求 LCA
树剖求 LCA 是我觉得最实用的一种方法了,如果平常你要求 LCA 的话,那么我首推树剖。
树剖求 LCA 的原理很简单,就是不断跳链。显然如果 \(x\) 和 \(y\) 在同一条链上那么深度更浅的那个就是 LCA。否则考虑将一个点跳出这条链。显然我们肯定跳链顶深度更浅的那个点,然后一直跳就行了。
时间复杂度最坏 \(O(\log n)\),最好可以 \(O(1)\)。
代码:
int LCA(int x,int y)
{
while(top[x]!=top[y])
{
if(depth[top[x]]<depth[top[y]])
{
swap(x,y);
}
x=fa[top[x]];
}
if(depth[x]<depth[y])
{
return x;
}
else
{
return y;
}
}
这是目前为止我觉得最好用的方法。
tarjan 求 LCA
这个方法很快,但是离线。可以做到 \(O(n)\) 求两点的 LCA。
具体的我也不太会,反正几乎不用。
dfs 序求 LCA
这是一个比较冷门的科技,不过可以弥补需要单独建欧拉序求 LCA 的情况。
dfs 序跟欧拉序比较像,唯一不同的是每个点只会在一开始被遍历的时候记录。因此 dfs 序求 LCA 看起来就没那么容易了。
不过你通过观察容易发现这样一个性质:点 \(x\) 走到点 \(y\) 的过程中必然会经过 LCA 的一个儿子节点,而且这个儿子节点是第一次被经过。
也就是说:如果 \(x\) 在 dfs 序上的位置是 \(id_x\),\(y\) 是 \(id_y\),那么在 \([id_x,id_y]\) 中必然会有 LCA 的儿子节点。
因此我们同样可以考虑找出 \([id_x,id_y]\) 之间深度最浅的点,这个点就是 LCA 的一个儿子节点……吗?
显然这是不一定的,因为如果 \(x\) 是 \(y\) 的祖先,此时在 \([id_x,id_y]\) 之间深度最浅的点就是 \(x\),正好是 LCA。解决这个问题的方法也很简单:只需要把区间换成 \([id_x+1,id_y]\) 就行了。
那么如果 \(x=y\),就直接返回 \(x\) 即可。
这种方法也是 \(O(n\log n)\) 预处理,\(O(1)\) 查询。不过比欧拉序求 LCA 少一个二倍的常数。
代码:
int LCA(int x,int y)
{
if(x==y)
{
return x;
}
if(id[x]>id[y])
{
swap(x,y);
}
int l=id[x]+1,r=id[y];
int k=log2(r-l+1);
if(depth[st[l][k]]<depth[st[r-(1<<k)+1][k]])
{
return fa[st[l][k]];
}
else
{
return fa[st[r-(1<<k)+1][k]];
}
}

浙公网安备 33010602011771号