LCA->最近公共祖先(洛谷3379)

关于LCA的倍增跟ST的倍增：一个是树上从当前深度往上倍增，倍增上限不超过当前深度，一个是数组中从左往右倍增，倍增上限不超过右边界。
不过在树中倍增要先处理出当前点的深度才能进行倍增，而数组中可以直接根据下标跟有边界的距离计算。

---

void solve(){
    int n, m, root;
    cin >> n >> m >> root;

    vector<vector<int>> al(n + 1);
    for (int i = 1; i < n; ++i){
        int u, v;
        cin >> u >> v;
        al[u].emplace_back(v);
        al[v].emplace_back(u);
    }

    int p = 0;
    for (int i = 0; (1 << i) < n; ++i){
        p = i;
    }

    vector<int> depth(n + 1);
    vector<vector<int>> dp(n + 1, vector<int>(p + 1));

    function<void(int, int, int)> dfs = [&](int u, int p, int d){
        depth[u] = d;
        dp[u][0] = p;
        for (int i = 1; (1 << i) <= d; ++i){
            dp[u][i] = dp[dp[u][i - 1]][i - 1];
        }
        for (auto& v : al[u]){
            if (v != p){
                dfs(v, u, d + 1);
            }
        }
    };

    dfs(root, 0, 1);


    while (m --){
        int u, v;
        cin >> u >> v;
        if (depth[u] < depth[v]){swap(u, v);}
        for (int i = p; i >= 0; --i){
            if (depth[u] - (1 << i) >= depth[v]){
                u = dp[u][i];
            }
        }
        if (u == v){
            cout << u << '\n';
            continue;
        }
        for (int i = p; i >= 0; --i){
            if (dp[u][i] != dp[v][i]){
                u = dp[u][i];
                v = dp[v][i];
            }
        }
        cout << dp[u][0] << '\n';
    }
}