最近公共祖先(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