LCA问题【RMQ+Tarjan】

LCA-求树上两点最近公共祖先问题

lrj的紫书上提供了一种将LCA问题转化为RMQ问题的方法，即dfs一次处理出一个序列，first(u)代表u第一次出现的下标，则对于u，v的最近公共祖先的下标即为RMQ(first(u), first(v))。

LCA->RMQ(在线处理)：

#include<bits/stdc++.h>
using namespace std;
const int N = 40010, M = 25;
int ver[2*N], R[2*N], first[N], dir[N], dp[2*N][M], tot;
/*ver[i]保存下标为i的结点编号，R[i]为下标为i的结点深度，first[i]为编号为i的结点第一次出现的下标，
dp[i][j]为起始下标为i，长度为1<<j的区间的最小深度的结点的下标*/
bool vis[N];
struct Node {
    int to, w;
};
vector<Node> G[N];

void dfs(int u, int dep) {
    vis[u] = true; ver[++tot] = u; first[u] = tot; R[tot] = dep;
    for (int i = 0; i < G[u].size(); ++i) {
        int v = G[u][i].to, w = G[u][i].w;
        dir[v] = dir[u] + w;  
        if (vis[v]) continue;
        dfs(v, dep+1);
        ver[++tot] = u; R[tot] = dep; 
    }
}

void RMQ_init(int l, int r) {
    for (int i = l; i <= r; ++i) dp[i][0] = ver[i];
    for (int k = 1; (1<<k) <= r-l+1; ++k)
        for (int i = l; i + (1<<k) <= r; ++i) {
            int a = dp[i][k-1], b = dp[i+(1<<(k-1))][k-1];
            if (R[a] > R[b]) dp[i][k] = b;
            else dp[i][k] = a;
        }
}

int RMQ(int l, int r) {
    int k = 0;
    while ((1<<(k+1)) <= r-l+1) ++k;
    int a = dp[l][k], b = dp[r-(1<<k)][k];
    if (R[a] > R[b]) return b;
    else return a; 
}

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

int main() {
    int n;
    while (cin >> n) {
        memset(dir, 0, sizeof(dir));
        memset(vis, 0, sizeof(vis));
        for (int i = 1; i <= n; ++i) G[i].clear();
        tot = 0;
        int a, b, c;
        for (int i = 1; i < n; ++i) {
            cin >> a >> b >> c;
            G[a].push_back(Node{b, c});
        }
        dfs(1, 1);
        RMQ_init(1, 2*n-1);
        int q, u, v;
        cin >> q;
        while (q--) {
            cin >> u >> v;
            cout << LCA(u, v) << endl;
        }
    }

    return 0;
}

Tarjan算法（离线处理）：

具体思想不再阐述，下图代表处理编号10的结点的询问时的状态（同色代表处于同一个集合）；

#include<bits/stdc++.h>
using namespace std;
const int maxn = 10005;
int p[maxn], anc[maxn];
bool vis[maxn];
vector<int> G[maxn];
vector<int> q[maxn];

int find(int x) {return x == p[x] ? x : p[x] = find(p[x]);}

void Union(int x, int y) {
    x = find(x); y = find(y);
    if (x == y) return;
    p[y] = x;
}

void LCA(int u) {
    anc[u] = u;
    for (int i = 0; i < G[u].size(); ++i) {
        int v = G[u][i];
        LCA(v);
        Union(u, v);
        anc[find(u)] = u;
    }
    vis[u] = true;
    for (int i = 0; i < q[u].size(); ++i) {
        int v = q[u][i];
        if (!vis[v]) continue;
        printf("LCA(%d, %d): %d
", u, v, anc[find(v)]);
    }
}

int main() {
    int n;
    while (~scanf("%d", &n)) {
        int a, b, k;
        memset(vis, 0, sizeof(vis));
        for (int i = 1; i <= n; ++i) G[i].clear(), p[i] = i;
        for (int i = 1; i < n; ++i) {
            scanf("%d%d", &a, &b);
            G[a].push_back(b);
        }
        scanf("%d", &k);
        for (int i = 0; i < k; ++i) q[i].clear();
        while (k--) {
            scanf("%d%d", &a, &b);
            q[a].push_back(b);
            q[b].push_back(a);
        }
        LCA(1);
    }

    return 0;
}