LCA入门

LCA入门（最小共同祖先入门）

离线tarjan算法（离线处理）

将树建好，将询问的值先读入，然后再逐个询问并处理询问的两点，求出共同祖先存入数组，最后直接逐个输出。

铁子哥板子

const int MAXN=44000;
int fa[MAXN], vis[MAXN], ans[MAXN], dis[MAXN];
int head[MAXN], tot, degree[MAXN];
vector<int> g[MAXN];
vector<int> q[MAXN];
vector<int> qid[MAXN];
struct Edge {
    int nxt, v, w;

    Edge () {}

    Edge (int nxt, int v, int w) : nxt(nxt), v(v), w(w) {}
}edge[MAXN*4];

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

void merge(int x, int y){
    fa[find(x)]=find(y);
}

void dfs(int u, int f) {
    vis[u] = 1;
    for (int i = 0; i < q[u].size(); i++) {
        int v = q[u][i], id = qid[u][i];
        if (vis[v] == 0) continue;
        ans[id] = find(v);
    }

    for (int i = head[u]; i != -1; i = edge[i].nxt) {
        int v = edge[i].v;
        if (v == f) continue;
        dfs(v, u);
        merge(v, u);
    }
}

void add(int u, int v, int w){
    edge[tot] = Edge(head[u], v, w);
    head[u] = tot++;
    edge[tot] = Edge(head[v], u, w);
    head[v] = tot++;
}

读入询问点

for(int i = 1; i<= m; i++){
            int x, y;
            scanf("%d %d", &x, &y);
            q[x].push_back(y);
            qid[x].push_back(y);
            q[y].push_back(x);
            q[y].push_back(x);
        }

例题hdu2586
题意就是给你一个LCA无向图，让你求两个点之间的最小距离dis，利用lca就是x点到所有点的共同祖先距离加上去y点到所有点的共同祖先距离减去两倍x和y的共同祖先到所有点的共同祖先距离

本䐞鲫的代码（铁子哥改良版）下有本人手敲注释

#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<string>
#include<algorithm>
#include<vector>

using namespace std;
const int MAXN=44000;
int fa[MAXN], vis[MAXN], ans[MAXN], dis[MAXN];
int head[MAXN], tot, degree[MAXN];
vector<int> g[MAXN];
vector<int> q[MAXN];
vector<int> qid[MAXN];
struct Edge {
    int nxt, v, w;
//nxt是边的下标，v是子节点，w是边权
    Edge () {}

    Edge (int nxt, int v, int w) : nxt(nxt), v(v), w(w) {}
}edge[MAXN << 1];

int find(int x){//并查集查找(是否为同一祖先节点)
    return x == fa[x]? x : fa[x] = find(fa[x]);
}

void merge(int x, int y){//并查集并入集合(父节点为同一点的所有点的集合)
    fa[find(x)]=find(y);
}

void dfs(int u, int f) {//任意点开始深搜
    vis[u] = 1;//将u子节点并入集合(已经搜索)
    for (int i = 0; i < q[u].size(); i++) {//离线队列询问
        int v = q[u][i], id = qid[u][i];
        if (vis[v] == 0) continue;//如果该节点未被搜索，则直接下一个循环
        ans[id] = dis[u] + dis[v] - 2 * dis[find(v)];
        //保存答案
    }

    for (int i = head[u]; i != -1; i = edge[i].nxt) {
        //开始查找lca
        int v = edge[i].v;
        if (v == f) continue;
        dis[v] = dis[u] + edge[i].w;
        //子节点v到最远祖先的距离
        dfs(v, u);//往下深搜
        merge(v, u);//将两点并入一个集合
    }
}

void add(int u, int v, int w){//加边，点，边权
    edge[tot] = Edge(head[u], v, w);
    head[u] = tot++;
    edge[tot] = Edge(head[v], u, w);
    head[v] = tot++;
    //无向图所以要来一遍正的一遍反的
}

int main(){
    int t;
    scanf("%d", &t);//t组输入
    while(t--){
        int n, m;
        scanf("%d %d", &n, &m);
        for(int i = 1;i<=n;i++){
            g[i].clear(),q[i].clear(),qid[i].clear(),vis[i]=0, degree[i]=0;
        }
        for (int i = 1; i <= n; ++i) {
            fa[i] = i, head[i] = -1, dis[i] = 0;
        }
        tot=0;
        //以上都是读入和初始化
        for(int i=1;i<n;i++){
            int p1, p2, d;
            scanf("%d %d %d", &p1, &p2, &d);
            add(p1, p2, d);
            //读入图
        }


        for(int i = 1; i<= m; i++){
            int x, y;//存入询问
            scanf("%d %d", &x, &y);
            q[x].push_back(y);
            qid[x].push_back(i);
            q[y].push_back(x);
            qid[y].push_back(i);
        }

        dfs(1, 0);//处理图，完成询问处理出点，然后将答案存入ans

        for(int i = 1;i <= m; i++){
            printf("%d\n", ans[i]);//输出answer
        }
    }
    return 0;
}

在线倍增

先存图（深搜），然后读入要询问的点，在放进LCA函数中求得共同祖先

铁子哥模板

const int MAXN=11000;

vector<int> g[MAXN];
int degree[MAXN], par[MAXN][20], dep[MAXN];

void dfs(int u, int fa){
    dep[u] = dep[fa]+1;
    par[u][0] = fa;
    for(int i=1;i<20;i++){
        par[u][i] = par[par[u][i-1]][i-1];
    }
    for(int i = 0;i<g[u].size();i++){
        int v=g[u][i];
        if(v == fa)continue;
        dfs(v, u);
    }
}

int lca(int u, int v){
    if(dep[u] < dep[v])swap(u, v);//把深度大的赋给u
    for(int i = 19;i >= 0; i--){//遍历20遍
        if(dep[par[u][i]] >= dep[v]) {//如果u的的深度依然大于v的深度
            u = par[u][i];//往上跳2^i个节点
        }
    }

    if(u==v)return u;//若此时u跟v相等表明他们跳到了同一个节点
    for(int i=19;i>=0;i--){//再遍历20次
        if(par[u][i] != par[v][i]) {//如果u的上一个父节点和v的上一个父节点不同
            u=par[u][i];//u往上跳2^i个节点
            v=par[v][i];//v往上跳2^i个节点
        }
    }
    return par[u][0];
}

存边

        for(int i=1;i<n;i++){
            int p1, p2;
            scanf("%d %d", &p1, &p2);
            g[p1].push_back(p2);//存边，p1到p2的边
            degree[p2]++;//p2的入度加一
        }

找所有点的共同祖先入度为零的点存图

        int root;
        for(int i=1; i<=n;i++){
            if(degree[i] == 0){
                root = i;
                break;
            }
        }
        dfs(root, 0);

询问两点的共同祖先

        int x, y;//询问的点
        scanf("%d %d", &x, &y);
        printf("%d\n", lca(x, y));