当我们想要知道从最快地从A走到B时，朴素的想法是找出任何一个点走任意步会到达的地方，但是这样太耗内存。
但是实际上可以只记录走1,2,4,8,16步能到达的地方
从A出发：若跳8个格子（超过B了，放弃）
若跳4个格子（超过B了，放弃）
若跳2个格子（没超过B，跳吧）
若跳1个格子（没超过B，跳吧）
从B出发：…………
多么轻松的事情，只要一本很薄的小抄就可以了，最关键的是：它绝对不会连着跳两步都是跳相同的格子数，因为如果跳两次2个格子都是可行的话，那么它干嘛不跳4个格子捏？
从A出发跳1步到1（记录下来）
扫描二维码关注公众号，回复：
1731093 查看本文章
从1出发跳1步到2（记录下来）
…………（跳1步的记录完毕）
从A出发跳2步？就是从A出发跳1步再跳1步的到的地方，翻看小抄，直接誊写从1出发跳1步会到的2这个格子作为A跳2步会到的格子。
从1出发跳2步？跟刚才一样，直接誊写。
…………（跳2步的记录完毕）
从A出发跳4步？你还真去跳4步？不，它也就是等于从A出发跳2步到的2号点再跳2步会到的格子，那么我们直接誊写2号格子跳2步会到的格子就可以了。
以下转自：http://jiayuzun.coding.me/2016/08/05/bz-template/
算法理论
- 朴素算法：记录下每个节点的父亲，使节点u,v一步一步地向上找父亲，直到找到相同的“祖先”，即是
所求的答案，时间复杂度O(n) - 优化算法（倍增法）：利用二进制的思想，想办法使一步一步向上搜索变成以2^k的向上跳。所以
定义一个f[][]数组，使f[j][i]表示节点i的2^j倍祖先。
算法实现
1.预处理出所有节点的深度和父节点
* BFS防止爆栈 无法处理孩子个数
* DFS可能会爆栈 可以处理孩子个数 使用时建议扩栈
2.处理各节点的所有祖先节点
3.将所查询的两点上升到同一高度
* 找到祖先(以2^k的高度向上找)
* 未找到祖先，同时上升高度至找到公共祖先
附加代码
定义及初始化
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
const
int N =
100005;
int n , m , pre[N] , rt[N], mcnt;
//pre 邻接表数组 rt 求根节点 mcnt 邻接表下标变量
bool vis[N];
struct edge
{
int x , next;
} e[N <<
1];
//邻接表
int dep[N] , f[
17][N] , Lev , s[N];
//dep[]储存深度 1<<16 < N f[j][i] 表示i的第2^j个祖先 s[]孩子个数
void init()
{
memset(pre ,
-1 ,
sizeof(pre));
memset(rt,
0,
sizeof(rt));
mcnt =
0;
}
|
算法函数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
void addedge(int x, int y)//邻接表加边函数
{
e[mcnt].x = y,
e[mcnt].next = pre[x],
pre[x] = mcnt ++;
}
void dfs(int x , int fa)///也可以用bfs，但bfs不能统计节点孩子个数
{
dep[x] = dep[fa] +
1;
f[
0][x] = fa , s[x] =
1;
for (
int i = pre[x] ; i!=
-1 ; i = e[i].next)
{
int y = e[i].x;
if (y != fa)
{
dfs(y , x);
s[x] += s[y];
///节点x的孩子个数
}
}
}
// dfs处理后，要进一步处理得到节点的所有祖先
// for (j = 1 ; 1 << j < n ; ++ j)
// for (i = 1 ; i <= n ; ++ i)
// {
// f[j][i] = f[j - 1][f[j - 1][i]];
// }
// Lev = j - 1;
void bfs(int rt)///不需要求孩子个数，同时防止暴栈
{
queue<
int> q;
q.push(rt);
f[
0][rt] =
0, dep[rt] =
1, vis[rt] =
1;
while (!q.empty())
{
int fa = q.front();
q.pop();
for (
int i = pre[fa] ; ~i ; i = e[i].next)
{
int x = e[i].x;
if (!vis[x])
{
dep[x] = dep[fa] +
1;
f[
0][x] = fa , vis[x] =
1;
q.push(x);
}
}
}
}
int LCA(int x , int y)
{
if (dep[x] > dep[y])
{
swap(x , y);
}
for (
int i = Lev ; i >=
0 ; -- i)
///找y的第dep[y] - dep[x]个祖先
if (dep[y] - dep[x] >> i &
1)
//dep[y]-dep[x]刚好比2的i次方大时
{
y = f[i][y];
}
if (x == y)
{
return y;
}
for (
int i = Lev ; i >=
0 ; -- i)
//同一高度后开始找祖先
if (f[i][x] != f[i][y])
//不停的上次2的i次方，直到i==0
{
x = f[i][x] , y = f[i][y];
}
return f[
0][x];
}
int get_kth_anc(int x , int k) ///找x的第k个祖先
{
for (
int i =
0 ; i <= Lev ; ++ i)
if (k >> i &
1)
{
x = f[i][x];
}
return x;
}
|