LCA 总结

代码：

//RMQ求LCA
struct node {
    int v, w;
};
class LCA {
  private:
    vector<int>dep, pos, olx, dis;
    vector<vector<int>>st;
  public:
    LCA(vector<vector<node>> &G, int r) {
        int sz = G.size();
        pos.resize(sz);
        dis.resize(sz, );
        dep.resize(sz, );
        function<void(int, int)>dfs = [&](int u, int fa) {
            pos[u] = olx.size();
            olx.push_back(u);
            dep[u] = dep[fa] + ;
            for(auto &i : G[u]) {
                if(i.v != fa) {
                    dis[i.v] = dis[u] + i.w;
                    dfs(i.v, u);
                    olx.push_back(u);
                }
            }
        };
        dfs(r, r);
        int n = olx.size(), m = log2(n) + ;
        st.resize(n);
        for(int i = ; i < n; i++) {
            st[i].resize(m);
            st[i][] = olx[i];
        }
        for(int j = ; j < m; j++) {
            for(int i = ; i + ( << j) <= n; i++) {
                int x = st[i][j - ], y = st[i + ( << (j - ))][j - ];
                st[i][j] = dep[x] < dep[y] ? x : y;
            }
        }
    }
    int que(int u, int v) {
        int l = pos[u], r = pos[v];
        if(l > r) swap(l, r);
        int k = log2(r - l + );
        int x = st[l][k], y = st[r - ( << k) + ][k];
        return dep[x] < dep[y] ? x : y;
    }
    int dist(int u, int v) {
        int lca = que(u, v);
        return dis[u] + dis[v] -  * dis[lca];
    }
};

倍增求LCA
struct node {
    int v, w;

};
class LCA {
  private:
    vector<int>dep;
    vector<vector<int>>anc;
    vector<int>dis;
  public:
    LCA(vector<vector<node>> &G, int r) {
        int n = G.size(), m = log2(n) + ;
        anc.resize(n);
        for(auto &i : anc) i.resize(m);
        dep.resize(n);
        dis.resize(n);
        function<void(int, int)>dfs = [&](int u, int fa) {
            anc[u][] = fa;
            dep[u] = dep[fa] + ;
            for(auto &i : G[u]) {
                if(i.v != fa) {
                    dis[i.v] = dis[u] + i.w;
                    dfs(i.v, u);
                }
            }
        };
        dfs(r, r);
        for(int j = ; j < m; j++) {
            for(int i = ; i < n; i++) {
                anc[i][j] = anc[anc[i][j - ]][j - ];
            }
        }
    }
    int que(int u, int v) {
        if(dep[u] < dep[v]) swap(u, v);
        for(int i = log2(dep[u]); i >= ; i--) {
            if(dep[u] - ( << i) >= dep[v]) u = anc[u][i];
        }
        if(u == v) return u;
        for(int i = log2(dep[u]); i >= ; i--) {
            if(anc[u][i] != anc[v][i]) {
                u = anc[u][i];
                v = anc[v][i];
            }
        }
        return anc[u][];
    }
    int dist(int u, int v) {
        int lca = que(u, v);
        return dep[u] + dep[v] - dep[lca] * ;
    }
    int kth_anc(int u, int k) { //u节点在k层的祖先
        if(dep[u] < k) return -;
        int d = dep[u] - k;
        for(int i = log2(d); i >= ; i--) {
            if(d - ( << i) >= ) {
                d -= ( << i);
                u = anc[u][i];
            }
        }
        return u;
    }
};

tarjan求LCA
struct node {
    int v, w;
};
vector<int> LCA(vector<vector<node>> &G, int r, vector<node> &q) {
    int n = G.size(), m = q.size();
    vector<vector<node>>que(n);
    vector<int>bcj(n), ans(m), dis(n);
    iota(bcj.begin(), bcj.end(), );
    for(int i = ; i < m; i++) {
        que[q[i].v].push_back({q[i].w, i});
        que[q[i].w].push_back({q[i].v, i});
    }
    function<int(int)>gr = [&](int k) {
        return k == bcj[k] ? k : bcj[k] = gr(bcj[k]);
    };
    function<void(int, int)>dfs = [&](int u, int fa) {
        cout << u << endl;
        for(auto &i : G[u]) {
            if(i.v != fa) {
                dis[i.v] = dis[u] + i.w;
                dfs(i.v, u);
                bcj[i.v] = u;
            }
        }
        for(auto &i : que[u]) {
            if(bcj[i.v] != i.v || i.v == u) {
                ans[i.w] = gr(i.v);
            }
        }
    };
    dfs(r, r);
    return ans;
}