LCA在线算法学习笔记

LCA就是求树上两个节点的最近公共祖先。

LCA的在线算法最好的就是ST算法，这是一种基于RMQ（区间最小值）的算法，总的来说，就是利用dfs搜索得到一个序列，然后在这个序列中确定一个区间内，找到最小值的编号就是对应两点的LCA。

举例说明，如图所示一棵树：

通过深搜可以得到这样一个序列：
节点ver： 1 3 1 2 4 2 5 6 5 7（左到右）
深度  R ：1 2 1 2 3 2 3 4 3 4 
首位first：1 2 4 5 7 8 10      （即这个数第一次出现的位置）

利用一次dfs求出上面三个数组，之后如果想要求解两个节点的LCA，比如要求解4，7两个节点的LCA，只要通过first数组找4和7第一次出现的下标分别是5和10，也就是在深度R数组中找到下标5到8这一段，也就是3 2 3 4 3 4，可以发现最小深度是2，而所对应的节点编号就是2，所以4和7的LCA就是2。

ST算法需要用到RMQ，也就是通过dp的思想求解一段区间内的最小值的下标，这样每次查询的复杂度就是O(logn)。

最后附上HDU 2586（LCA模板题）的代码：

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 4e4 + 10;

struct node {
    int v, w;
};

int dfs_cnt;
int dp[2 * MAXN][25];
int R[2 * MAXN], ver[2 * MAXN], dis[MAXN], fir[MAXN];
vector <node> tree[MAXN];

void dfs(int u, int pre, int deep) {
    fir[u] = ++dfs_cnt;
    ver[dfs_cnt] = u; R[dfs_cnt] = deep;
    int cnt = tree[u].size();
    for (int i = 0; i < cnt; i++) {
        int v = tree[u][i].v, w = tree[u][i].w;
        if (v == pre) continue;
        dis[v] = dis[u] + w;
        dfs(v, u, deep + 1);
        ver[++dfs_cnt] = u; R[dfs_cnt] = deep;
    }
}

void ST(int n) {
    for (int i = 1; i <= n; i++) dp[i][0] = i;
    for (int j = 1; (1 << j) <= n; j++) {
        for (int i = 1; i + (1 << j) - 1 <= n; i++) {
            int x = dp[i][j - 1], y = dp[i + (1 << (j - 1))][j - 1];
            dp[i][j] = R[x] < R[y] ? x : y;
        }
    }
}

int RMQ(int l, int r) {
    int k = 0;
    while ((1 << (k + 1)) <= r - l + 1) ++k;
    int x = dp[l][k], y = dp[r - (1 << k) + 1][k];
    return R[x] < R[y] ? x : y;
}

int LCA(int u, int v) {
    int x = fir[u], y = fir[v];
    if (x > y) swap(x, y);
    return ver[RMQ(x, y)];
}

int main() {
    //freopen("in.txt", "r", stdin);
    int T;
    cin >> T;
    while (T--) {
        int n, m;
        scanf("%d%d", &n, &m);
        for (int i = 0; i <= n; i++) tree[i].clear();
        for (int i = 1; i < n; i++) {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            tree[u].push_back((node){v, w});
            tree[v].push_back((node){u, w});
        }
        dfs_cnt = 0;
        dis[1] = 0;
        dfs(1, -1, 1);
        ST(2 * n - 1);
        while (m--) {
            int u, v;
            scanf("%d%d", &u, &v);
            int pa = LCA(u, v);
            printf("%d\n", dis[u] + dis[v] - 2 * dis[pa]);
        }
    }
    return 0;
}