前置知识
没啥,倍增和LCA的定义这里会有介绍的
不过代码里面用到了链式前向星的存储方法
反正你得会存图你才能做LCA的题
倍增法
算法思路
假设有一个小白兔,想从第0个格子跳到第23个格子,它可以一次性跳到任意一个格子中,但它不知道终点再哪个格子,不过它能够判断它是在终点的前方还是后方还是正好在终点。
因为它不知道终点在哪里,漫无目的地跳肯定是不行的,要想保险只能一格一格地走,但是这样子 O ( n ) O(n) O(n)的时间复杂度又太浪费时间了。
考虑倍增:
让小白兔每次只能跳刚好
2
n
2^n
2n个格子,然后用以下的方式跳
它先尝试跳32个,过了,然后回来,又尝试跳16个,还没到,这个时候它距离终点又23-16=7个格子,它尝试跳8个(因为如果这个时候还跳16个格子的话,就和跳32个格子没区别了,原理: 2 n + 2 n = 2 n + 1 2^n+2^n=2^{n+1} 2n+2n=2n+1),过了,回来尝试跳4个,还没到,距离7-4=3个格子,然后它尝试跳2个格子,还没到,然后它尝试跳1个格子,终于跳到了终点
为什么这样子呢,你会发现,如果你跳两次1格,其实效果是等价于跳1次2格的。那为何不一次性跳2格呢?
如果你跳两次2格,效果是等价于跳一次4格的。那为何不一次性跳4格呢?
。。。
同时,任何一个数都可以表示成为一些2的n次方的数之和的。比如23就是
2
4
+
2
2
+
2
1
+
2
0
2^4+2^2+2^1+2^0
24+22+21+20四次就可以了,而一个一个地跳就得跳23次
这便是倍增算法了,时间复杂度: O ( log n ) O(\log n) O(logn)
倍增法求LCA
LCA
图片来自于这里
如有侵权请联系删除
LCA即Lowest Common Ancestor, 即最近公共祖先
说人话就是树上两个节点共同的祖先之中,离根节点最远的
例如:6号节点的祖先为4,2,1
8号节点的祖先为5,2,1
那么6号节点和8号节点拥有的公共的祖先就是:2,1
其中离根节点最远的是2号节点(1号节点就是根节点,同时根节点是所有节点的公共祖先)
引入
采用暴力方法进行计算:
假设我们要求6和5的LCA
在求解之前先把整个图BFS一边,分个层次
就像这样
我们发现6在第3层,而5在第2层,那么我们就将6往上跳,跳到和5同层,也就是4
然后4和5一起向上跳,跳到了2,重合了,那么2就是6和5的最近公共祖先
这样子的平均时间复杂度为 O ( log n ) O(\log n) O(logn),最坏时间复杂度为 O ( n ) O(n) O(n)
想要这个算法的时间复杂度保持在log n是很难得,你得保证树平衡(参见平衡树),如果出题人毒瘤一点,给一个链图,那你就等着 TLE \text{\color{Blue}TLE} TLE吧
那么,我们可以通过倍增来优化这样子的往上找祖先的步骤
倍增法求解LCA
算法思路
进行一个预处理:令f[i][j]
为第i个节点的第j个祖先
首先通过倍增将节点i
和j
的深度变成一样的。
然后倍增找他们两个节点的共同的第
2
k
2^k
2k个祖先
如何预处理f[][]
数组呢?
要知道如果一个一个地预处理,就和暴力没区别了
众所周知:
2
n
−
1
+
2
n
−
1
=
2
n
2^{n-1}+2^{n-1}=2^n
2n−1+2n−1=2n
所以f[i][n]=f[f[i][n-1]][n-1]
也就是i
号节点的第n个父亲就是i
号节点的第n-1个父亲的第n-1个父亲,通过这样预处理即可
代码解释
//利用链式前向星进行存图
#include <cstdio>
#include <iostream>
using namespace std;
inline int read()
{
register int x=0,f=0;
register char ch=getchar();
while(ch<'0' || ch>'9')
f|=ch=='-',ch=getchar();
while(ch>='0' && ch<='9')
x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
return f?-x:x;
}
struct edge
{
int to,nxt;
};
edge e[maxn<<1];
int head[maxn],cnt;
int d[maxn],f[maxn][32],_log[maxn];
inline void add_edge(int from, int to)
{
cnt++;
e[cnt].to=to;
e[cnt].nxt=head[from];
head[from]=cnt;
}
void init_lg()
{
for(int i=1;i<=n;i++)
lg[i]=lg[i-1]+(1<<lg[i-1]==i);
//这个我也不大好解释,就相当于是lg[2的k次方-1]=k
}
void bfs(int u, int fa)//u代表当前节点,fa代表u的父亲
{
f[u][0]=fa;//因为u节点上面2^0个点就是u上面的一个点,就是u的父亲
d[u]=d[fa]+1;//存储每一个节点的深度
for(int i=1;i<=lg[d[u]];i++)
f[u][i]=f[f[u][i-1]][i-1];//f[][]数组
for(int i=head[u];i;i=e[i].nxt)
if(e[i].to!=fa)//遍历节点u的儿子们
dfs(e[i].to,u);
//那么u就是它的儿子们的父亲,e[i].to就是u的儿子
}
void lca(int x, int y)
{
if(d[x]<d[y])
swap(x,y);//为了方便我们让x的深度深一点
while(d[x]>d[y])
x=f[x][lg[d[x]-d[y]]-1];
//说人话就是:x变成x的第lg[d[x]-d[y]]-1个父亲
//也就是x变成x的第2的(d[x]-d[y])次方-1个父亲
//d[x]-d[y]就是两个节点的深度差
if(x==y)
return x;//如果y本身就是x的祖先,那么x在和y深度相同的时候就会重合,直接返回即可
for(int k=lg[d[x]]-1;k>=0;k--)
if(f[x][k]!=f[y][k])
x=f[x][k],y=f[y][k];//一起向上问候祖宗(雾
return f[x][0];//因为现在x已经变成了x,y的LCA的儿子了,所以返回x的父亲即可
}
int main()
{
int n,m,s;
cin>>n>>m>>s;
for(int i=1;i<=n-1;i++)
{
int x,y;
cin>>x>>y;
add_edge(x,y);
add_Edge(y,x);
}
init_lg();
dfs(s,0);//从树根开始,DFS遍历层数(用BFS也行)
for(int i=1;i<=m;i++)
{
int x,y;
cin>>x>>y;
cout<<lca(x,y);
}
}
这就结束了对于LCA的讲解