树链剖分与倍增求\(LCA\)
首先我要吐槽机房的辣基供电情况，我之前写了一上午，马上就要完成的时候突然停电，然后\(GG\)成了送链剖分
其次，我没歧视\(tarjan LCA\)
1.倍增求\(LCA\)
理解较为简单的一种方法，但速度略慢
倍增是啥?
每个数字都可以拆成几个二的整数次的和，我们可以找出每个数字是由哪几个二的整数次的数合成的
比如说\(14 _ {10} = 1110_2 = 1000 _2 + 100 _2 + 10 _2 = 8 _ {10} + 4 _{10} + 2 _{10}\)
那么我们如果要统计一段长度为十四的区间的最小值，我们就可以先统计前八个数的最小值，再统计之后的四个，再统计之后的两个。
我们可以用\(f[i][j]\)表示从\(i\)开始往后\(2^j\)长度的最小值
给宁康康代码
for( int i = 1; i <= 23; i++ ){
for( rint j = 1; j <= n; j++ ){
//a[i][j]存的是i往后2的j次长度的区间的右节点是哪儿
f[i][j] = min( f[i][j - 1], f[a[i][j - 1]][j - 1] );
}
}
下面这个东西是啥意思呢
f[i][j - 1], f[a[i][j - 1]][j - 1]
\(2^j = 2^{j-1} +2^{j - 1}\) 比如说 \(2^4 = 2 ^ 3 +2 ^ 3\)
树上倍增
在每个叶节点到根节点的链上做倍增
图片演示一哈(如果打开我的博客就会发现我这种蒟蒻说不清话只会画图
应该比较显然吧???
我们在求\(LCA\)前\(dfs\)一遍，统计出每个叶节点的\(f[i][1]\)（也就是父节点）和\(dep[i]\)（就是该节点所处深度，规定根节点深度为1）。然后跑一遍倍增，预处理每个叶节点的向上\(2^i\)个祖宗是谁。
然后倍增求\(LCA\)，我们可以先看两个点是否在同一深度，不在的话就把比较低的那个点往上走一走，直到走到同一深度。注意在跳的时候要从大到小枚举，给宁康康代码，宁再把上面的\(14\)那个例子带进去从\(1\)到\(20\)枚举一下子就懂了
inline int lca( int x, int y ){
if( dep[x] < dep[y] ) swap( x, y );
for( rint i = 20; i >= 0; i-- ){
if( dep[f[x][i]] >= dep[y] ) x = f[x][i];
}
if( x == y ) return x;
for( rint i = 20; i >= 0; i-- ){
if( f[x][i] == f[y][i] ) continue; //如果跳的一样的话就可能是LCA或者是LCA的祖先，所以先跳到最后一个不一样的，再往上跳一个
else x = f[x][i], y = f[y][i];
}
return f[x][0];
}
\(AC\)代码
#include<bits/stdc++.h>
using namespace std;
#define rint register int
int n, m, s, cnt, dep[500005], f[500005][23], head[500005];
struct edge{
int to, nxt;
}a[500005<<1];
inline int read( void ){
int re = 0, f = 1;
char ch = getchar();
while( ch > '9' || ch < '0' ){
if( ch == '-' ) f = -1;
ch = getchar();
}
while( ch >= '0' && ch <= '9' ){
re = re * 10 + ch - '0';
ch = getchar();
}
return re * f;
}
inline void addedge( int x, int y ){
a[++cnt].to = y;
a[cnt].nxt = head[x];
head[x] = cnt;
}
inline void dfs( int x, int fa ){
dep[x] = dep[fa] + 1;
f[x][0] = fa;
for( rint i = 1; ( 1 << i ) <= dep[x]; i++ ){
f[x][i] = f[f[x][i - 1]][i - 1];
}
for( rint i = head[x]; i; i = a[i].nxt ){
int v = a[i].to;
if( v == fa ) continue;
dfs( v, x );
}
return ;
}
inline int lca( int x, int y ){
if( dep[x] < dep[y] ) swap( x, y );
for( rint i = 20; i >= 0; i-- ){
if( dep[f[x][i]] >= dep[y] ) x = f[x][i];
}
if( x == y ) return x;
for( rint i = 20; i >= 0; i-- ){
if( f[x][i] == f[y][i] ) continue;
else x = f[x][i], y = f[y][i];
}
return f[x][0];
}
int main( void ){
n = read(); m = read(); s = read();
for( rint i = 1; i <= n - 1; i++ ){
int x, y; x = read(); y = read();
addedge( x, y ); addedge( y, x );
}
dfs( s, 0 );
int u, v;
for( rint i = 1; i <= m; i++ ){
u = read(); v = read();
cout << lca( u ,v ) << endl;
}
return 0;
}
树链剖分
树链剖分其实有好多种剖分方法，但这里只介绍轻重边剖分
含义
一个节点只能有一个重儿子。
链 : 连续的重/轻边构成一条链。(图中从\(1\)到\(14\)即一条重链)
\(dep[i]\) : \(i\)节点的深度，规定根节点深度为\(1\)。
\(fa[i]\) : \(i\)节点的父亲。
\(son[i]\) : \(i\)节点的重儿子。
\(siz[i]\) : 以\(i\)节点为根的子树的大小。
\(top[i]\) : \(i\)所在链的根。(图中从\(1\)到\(14\)的链的根为\(1\))
重边 : 以\(i\)节点的儿子中\(siz\)最大的儿子到\(i\)的连边，即图中的粗边(该儿子也叫重儿子)。
轻边 : 处重边外的其他边。
步骤
首先\(dfs\)一遍，求出\(dep\),\(fa\),\(son\),\(siz\)，容易实现，给宁康代码
inline void dfs1( int now, int father, int de ){
siz[now] = 1; fa[now] = father; dep[now] = de;
int maxn = -1;
for( rint i = 0; i < vec[now].size(); i++ ){
int v = vec[now][i];
if( v == father ) continue ;
dfs1( v, now, de + 1 );
siz[now] += siz[v];
if( siz[v] > maxn ){
maxn = siz[v];
son[now] = v;
}
}
}
然后再\(dfs\)一遍，处理出每个点的\(top\)，也就是所在链的顶点，其中轻链的顶点是它自己。
给宁康康代码
inline void dfs2( int now, int topf ){
top[now] = topf;
if( !son[now] ) return ;
dfs2( son[now], topf );
for( rint i = 0; i < vec[now].size(); i++ ){
int v = vec[now][i];
if( v == fa[now] || v == son[now] ) continue;
dfs2( v, v );
}
}
如果一个点要跳到它的\(lca\)，就一定会跳到它的\(lca\)所在链（废话……
那么我们要判定是否已经找到\(lca\)，就只需要看当前两点\(xy\)是否在同一条链上，其实就是看两个点的\(top\)是否相等，如果不相等的话，我们就让深度大的点一次性跳完一整条重链，然后再跳一步，走上另一条重链，再重复以上比较\(top\),跳重链的过程
我们可以发现非叶节点一定在某条重链上，所以我们一次性跳完一条重链，再跳一步，就会跳上另一条重链，所以查找\(lca\)的复杂度是小于\(logn\)的
给宁康康代码
inline int lca( int x, int y ){
while( top[x] != top[y] ){
if( dep[top[x]] < dep[top[y]] ) swap( x, y );
x = fa[top[x]];
}
if( dep[x] > dep[y] ) return y;
return x;
}
全部代码：
#include<bits/stdc++.h>
using namespace std;
#define rint register int
int T, n, m;
int son[1000010], fa[1000010], siz[1000010], dep[1000010], top[1000010];
vector< int > vec[1000010];
inline int read( void ){
int re = 0, f = 1; char ch = getchar();
while( ch > '9' || ch < '0' ){
if( ch == '-' ) f = -1;
ch = getchar();
}
while( ch >= '0' && ch <= '9' ){
re = re * 10 + ch - '0';
ch = getchar();
}
return re * f;
}
inline void dfs1( int now, int father, int de ){
siz[now] = 1; fa[now] = father; dep[now] = de;
int maxn = -1;
for( rint i = 0; i < vec[now].size(); i++ ){
int v = vec[now][i];
if( v == father ) continue ;
dfs1( v, now, de + 1 );
siz[now] += siz[v];
if( siz[v] > maxn ){
maxn = siz[v];
son[now] = v;
}
}
}
inline void dfs2( int now, int topf ){
top[now] = topf;
if( !son[now] ) return ;
dfs2( son[now], topf );
for( rint i = 0; i < vec[now].size(); i++ ){
int v = vec[now][i];
if( v == fa[now] || v == son[now] ) continue;
dfs2( v, v );
}
}
inline int lca( int x, int y ){
while( top[x] != top[y] ){
if( dep[top[x]] < dep[top[y]] ) swap( x, y );
x = fa[top[x]];
}
if( dep[x] > dep[y] ) return y;
return x;
}
int main( void ){
n = read(); m = read();
for( rint i = 1; i < n; i++ ){
int u, v; u = read(); v = read();
vec[u].push_back( v );
vec[v].push_back( u );
}
dfs1( 1, 1, 1 );
dfs2( 1, 1 );
for( rint i = 1; i <= m; i++ ){
int x, y; x = read(); y = read();
printf( "%d\n", lca( x, y ) );
}
return 0;
}
如果要求树上两点最短距离，可以求\(lca\)
\(dis = dep[x] + dep[y] - 2 * lca\)