最近公共祖先(LCA)/倍增LCA
目录
题目描述:
分析：
链式前向星：
预处理lg数组：
DFS求解深度depth和fa数组：
LCA：
完整代码：
样例：
题目描述:
如题，给定一棵有根多叉树，请求出指定两个点直接最近的公共祖先。
输入格式
第一行包含三个正整数 N, M, S，分别表示树的结点个数、询问的个数和树根结点的序号。
接下来 N - 1 行每行包含两个正整数 x, y，表示 x 结点和 y 结点之间有一条直接连接的边（数据保证可以构成树）。
接下来 M 行每行包含两个正整数 a, b，表示询问 a 结点和 b 结点的最近公共祖先。
输出格式
输出包含 M 行，每行包含一个正整数，依次为每一个询问的结果。
分析：
使用暴力循环判断的方法一定会超时，故可使用倍增LCA，即一次性可以跳 2 ^ i 个，而不是一个一个向上跳，减少了时间空间开销。
链式前向星：
void add(int x, int y) {
//存储与x相连的下一个节点
e[++tot].t = y;
//存储以x为首的上一条边
e[tot].next = head[x];
//记录编号，这是第几条边
head[x] = tot;
}预处理lg数组：
//若(1 << lg[i - 1]) == i，则使得lg[i] + 1
//否则，lg[i] = lg[i - 1]
//eg.lg[0] ~ lg[99]的值为：
//0 1 2 2 3 3 3 3 4 4
//4 4 4 4 4 4 5 5 5 5
//5 5 5 5 5 5 5 5 5 5
//5 5 6 6 6 6 6 6 6 6
//6 6 6 6 6 6 6 6 6 6
//6 6 6 6 6 6 6 6 6 6
//6 6 6 6 7 7 7 7 7 7
//7 7 7 7 7 7 7 7 7 7
//7 7 7 7 7 7 7 7 7 7
//7 7 7 7 7 7 7 7 7 7
for(int i = 1; i <= n; ++i)
lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);DFS求解深度depth和fa数组：
//fa[i][j]指的是节点 i 的2 ^ j级祖先
void dfs(int now, int father) {
//fa[now][0]为now的父节点，故应赋值为father
fa[now][0] = father;
//深度加一
depth[now] = depth[father] + 1;
//因为2 ^ j = 2 ^ (j - 1) + 2 ^ (j - 1)，故依此求解数组
for(int i = 1; i <= lg[depth[now]]; ++i)
fa[now][i] = fa[fa[now][i - 1]][i - 1];
//寻找下个节点，继续填充fa数组
for(int i = head[now]; i; i = e[i].next)
//因为存储的是无向图，防止向上搜
if(e[i].t != father)
dfs(e[i].t, now);
}LCA：
int LCA (int x, int y) {
//让节点x作为较深的节点，避免多一次条件判断
//该代码可以翻译为，不妨令节点x的深度更深
if(depth[x] < depth[y])
swap(x, y);
//将 x 和 y 放在相同的深度上
while(depth[x] > depth[y])
x = fa[x][lg[depth[x] - depth[y]] - 1];
//此时在同一深度，且两点重合，意味着已找到最近公共祖先
if(x == y)
return x;
//两个节点一起向上跳，同时需要避免两点处于同一位置
//不然可能会出现，此时所求的是公共祖先，但不是最近的
//故循环结束后应该为，两点为最近公共祖先的子节点
for(int k = lg[depth[x] - 1]; k >= 0; --k)
if(fa[x][k] != fa[y][k]) {
x = fa[x][k];
y = fa[y][k];
}
//返回x节点的父节点
return fa[x][0];
}完整代码：
#include
using namespace std;
const int N = 5e5 + 10;
int n, m, s, tot = 0;
//lg[i]表示深度为i的节点一次性可以往上最多跳2 ^ (lg[i] - 1)个节点
//fa[i][j]指的是节点 i 的2 ^ j级祖先
int head[N], depth[N], fa[N][21], lg[N];
struct node {
int t, next;
}e[N * 2];
//链式前向星
void add(int x, int y) {
e[++tot].t = y;
e[tot].next = head[x];
head[x] = tot;
}
void dfs(int now, int father) {
//fa[now][0]为now的父节点，故应赋值为father
fa[now][0] = father;
//深度加一
depth[now] = depth[father] + 1;
//2 ^ j = 2 ^ (j - 1) + 2 ^ (j - 1)
for(int i = 1; i <= lg[depth[now]]; ++i)
fa[now][i] = fa[fa[now][i - 1]][i - 1];
for(int i = head[now]; i; i = e[i].next)
//因为存储的是无向图，防止向上搜
if(e[i].t != father)
dfs(e[i].t, now);
}
int LCA (int x, int y) {
//让节点x作为较深的节点，避免多一次条件判断
//该代码可以翻译为，不妨令节点x的深度更深
if(depth[x] < depth[y])
swap(x, y);
//将 x 和 y 放在相同的深度上
while(depth[x] > depth[y])
x = fa[x][lg[depth[x] - depth[y]] - 1];
//此时在同一深度，且两点重合，意味着已找到最近公共祖先
if(x == y)
return x;
//两个节点一起向上跳，同时需要避免两点处于同一位置
//不然可能会出现，此时所求的是公共祖先，但不是最近的
for(int k = lg[depth[x] - 1]; k >= 0; --k)
if(fa[x][k] != fa[y][k]) {
x = fa[x][k];
y = fa[y][k];
}
return fa[x][0];
}
int main() {
scanf("%d %d %d", &n, &m, &s);
int x, y;
for(int i = 1; i < n; ++i) {
scanf("%d %d", &x, &y);
add(x, y);
add(y, x);
}
//进行常数优化
for(int i = 1; i <= n; ++i)
lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
dfs(s, 0);
for(int i = 1; i <= m; ++i) {
scanf("%d %d",&x, &y);
printf("%d\n", LCA(x, y));
}
return 0;
} 样例：
输入：
5 5 4
3 1
2 4
5 1
1 4
2 4
3 2
3 5
1 2
4 5
输出：
4 4 1 4 4