给定 (u,v)，如何 O(1) 求 lca(u,v) 的孩子 u',v'，且分别为 u,v 的祖先或本身

问题描述

一棵树，\(q\) 次询问给定 \(u,v\)，保证 \(u,v\) 不为祖孙关系。设 \(p=\operatorname{lca}(u,v)\)，求 \(p\) 的一个孩子 \(u'\) 且 \(u'\) 为 \(u\) 的祖先或 \(u\) 本身，类似需要求 \(v'\)。

朴素解法

倍增可以做到 \(\mathcal{O}(\log n)\)，但太慢了。

优化解法

不妨令 \(\mathrm{idx}(u)<\mathrm{idx}(v)\)，考虑到 DFS 序求 \(p=\operatorname{lca}(u,v)\) 最后一步跳父亲前，如果 ST 表对于相同深度的点，选取 \(\operatorname{idx}\) 大的，就是求出了 \(v'\)，得到了 \(p\) 后，通过求 \(\operatorname{lca}(u,p)\) 最后一步不要跳父亲，就能得到 \(u'\)。

时间复杂度 \(\mathcal{O}(1)\)。

代码实现

cpp 复制代码

#include <cstdio>
#include <iostream>
#include <vector>
#include <tuple>
#include <cassert>
using namespace std;

const int N = 5e5 + 10;
const int lgN = __lg(N) + 1;

int n, q, rt;
vector<int> e[N];

int st[lgN][N], idx[N], dpt[N], fa[N], timer, R[N];

void dfs(int u) {
    st[0][idx[u] = ++timer] = u;
    for (int v : e[u]) {
        if (v == fa[u]) continue;
        fa[v] = u;
        dpt[v] = dpt[u] + 1;
        dfs(v);
    }
    R[u] = timer;
}
inline int Min(int u, int v) {
    return dpt[u] < dpt[v] ? u : v;
}
inline tuple<int, int, int> lca(int u, int v) {
    if (u == v) return { 0, 0, u };
    int U, V, p, iu = idx[u], iv = idx[v];
    bool F = false;
    if (iu > iv) swap(iu, iv), swap(u, v), F = true;
    int k = __lg(iv - iu);
    V = Min(st[k][iu + 1], st[k][iv - (1 << k) + 1]);
    p = fa[V];
    if (p == u) U = 0;
    else {
        int ip = idx[p];
        k = __lg(iu - ip++);
        U = Min(st[k][ip], st[k][iu - (1 << k) + 1]);
    }
    if (F) swap(U, V);
    return { U, V, p };
}

signed main() {
    scanf("%d%d%d", &n, &q, &rt);
    for (int i = 1, u, v; i < n; ++i) {
        scanf("%d%d", &u, &v);
        e[u].emplace_back(v);
        e[v].emplace_back(u);
    }
    dfs(rt);
    for (int k = 1; k < lgN; ++k)
        for (int i = 1; i + (1 << k) - 1 <= n; ++i)
            st[k][i] = Min(st[k - 1][i], st[k - 1][i + (1 << (k - 1))]);
    for (int u, v; q--; ) {
        scanf("%d%d", &u, &v);
        auto [U, V, p] = lca(u, v);
        printf("%d\n", p);
        fprintf(stderr, "u' = %d, v' = %d\n", U, V);
        assert(!U || (idx[U] <= idx[u] && idx[u] <= R[U]));
        assert(!V || (idx[V] <= idx[v] && idx[v] <= R[V]));
    }
    return 0;
}