LCA

33.2 求LCA

例题【33.4】 LCA问题

• 给你一棵树，有n个节点$1\le n\le 10^5$，然后有k个询问$1\le k\le 10^5$，每个询问有两个点a和b，求a和b的LCA。

LCA就是最近公共祖先问题。

求LCA的办法有很多：

\qquad 暴力的办法：首先设A是深度大的点，B是深度小的点，然后A一步一步的往上跳，一直到和B跳到同一个深度，然后A和B一起一步一步的跳，一直到A=B，那么这个点就是答案。

\qquad 但是$O(n\times k)$的时间复杂度肯定会超时，所以我们要想一下怎么优化了。

\qquad 因为么一个点，只有，一个父亲，所以，这道题可以使用倍增算法来优化他。

\qquad 初始条件：dp[i][0] = fa[i]。

\qquad dp[i][j]表示的含义：i的第$2^j$代的祖先。

\qquad 同理，$dp[i][1\to 20]$都能求出来了，所以倍增算法就很容易（如果这句话冒犯了你，请你原谅我）写出来了。时间复杂度为：$O(N\log N)$，不会超时

#include <bits/stdc++.h>
#include "ternminral/io.h" // 快读、快写
using namespace std;

const int N = 100010;
const int M = N * 2;

int head[N], pnt[M], nxt[M], E;
int dp[N][20];
int dep[N];

void initalizer()
{
    E = 0;
    memset(head, -1, sizeof head);
}

void dd(int a, int b)
{
    pnt[E] = b;
    nxt[E] = head[a];
    head[a] = E ++;
}

void dfs(int u, int f)
{
    dp[u][0] = f;
    for(int i = head[u]; i != -1; i = nxt[i])
    {
        int v = pnt[i];
        if(v != f)
        {
            dfs(v, u);
        }
    }
}

int ask(int x, int y)
{
    if(dep[x] < dep[y])
    {
        swap(x, y);
    }
    int delta = dep[x] - dep[y];
    // 先跳到同一个高度，X为较深的点。
    for(int i = 0; i < 20;i ++)
    {
        if(delta & (1 << i))
        {
            x = dp[x][i];
        }
    }
    if(x == y)
    {
        return x;
    }
    for(int i = 19; i >= 0; i --)
    {
        if(dp[x][i] != dp[y][i])
        {
            x = dp[x][i];
            y = dp[y][i];
        }
    }
    return dp[x][0];
}

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    initalizer();
    for(int i = 1; i <= m; i ++)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        dd(a, b);
    }
    dfs(1, 0);
    for(int i = 1; i < 20; i ++)
    {
        for(int j = 1; j <= n; j ++)
        {
            dp[j][i] = dp[dp[j][i - 1]][i - 1];
        }
    }
    int q;
    scanf("%d", &q);
    while(q --)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        printf("%d\n", ask(a, b));
    }
    return 0;
}