LCA（最近公共祖先）

hdu 2586
大意为给一个正边权的树，查询两点间距离。做法为，求出任意一点到根的距离，任意两点距离就是这两点到根的距离和减去二倍LCA到根距离。

Tarjan（离线）O(n)-O(1)

思想：在dfs的过程中将已被遍历过的子树（包括空子树）及其父节点归为一类，同一类的的节点的LCA就是这个父节点，两个不同类的节点共有同一个LCA。每次只处理与当前访问节点有关的询问（所以是离线算法），如果询问中的另外一个点已经被访问过，当回答询问先于向下遍历，LCA只可能是祖先。我们用并查集数组来的值直接来表示这个LCA，所以当前访问节点祖先的数组值就是自己的标号，显然这个数组值可以在第一次访问节点时初始化为该节点的标号，让后由其父节点为父节点自己的标号。

#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;

#define MP make_pair
#define PB push_back
int a[40010],depth[40010],n,m,vis[40010],ans[210];
vector<int> no[40010],q[40010],id[40010],len[40010];

int find(int p) {
    int q=p;
    while(a[p]) p=a[p];
    while(a[q]) {
        int tmp=a[q];
        a[q]=p;
        q=tmp;
    }
    return p;
}

void uni(int p,int q) {
    int i=find(p),j=find(q);
    if(i!=j) a[i]=j;
}

void dfs(int p,int fa,int l) {
    if(~fa) depth[p]=depth[fa]+l;
    a[p]=0;

    for(int i=0;i<q[p].size();i++)//询问部分
        if(vis[q[p][i]]) ans[id[p][i]]=depth[q[p][i]]+depth[p]-2*depth[find(q[p][i])];

    vis[p]=1;//询问部分与递归部分关于改行对称，两种写法没有实质区别

    for(int i=0;i<no[p].size();i++)//递归部分
        if(!vis[no[p][i]]) {
            dfs(no[p][i],p,len[p][i]);
            a[no[p][i]]=p;
        }
}

int main() {
    int t;
    scanf("%d",&t);
    while(t--) {
        memset(vis,0,sizeof(vis));
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++) {
            no[i].clear();
            q[i].clear();
            len[i].clear();
            id[i].clear();
        }
        for(int i=1;i<n;++i) {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            no[a].PB(b);
            no[b].PB(a);
            len[a].PB(c);
            len[b].PB(c);
        }
        for(int i=1;i<=m;i++) {
            int a,b;
            scanf("%d%d",&a,&b);
            q[a].PB(b);
            q[b].PB(a);
            id[a].PB(i);
            id[b].PB(i);
        }
        memset(vis+1,0,n*sizeof(int));
        memset(depth+1,0,n*sizeof(int));
        dfs(1,-1,0);
        for(int i=1;i<=m;i++)
            printf("%d\n",ans[i]);
//        printf("\n");
    }
    return 0;
}

倍增法（在线）O(nlogn)-O(logn)

思想：预处理出所有节点的深度和2^k(k=0...log(该点深度))倍祖先，1倍祖先就是父亲，2倍祖先是父亲的父亲......。先找到深度大的节点和浅层节点所在层同层的祖先节点，若两节点相同，则原节点为祖孙关系，直接返回标号；否则，找到深度最浅的一层使得两节点的祖先在该层不同，则这个祖先的父节点为LCA。上述调整使用了二分查找的策略，因为深度是否足够浅和不同祖先所在层是否足够浅，这两个问题在深度数组和2^k倍祖先数组中都体现出单调性。

#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <vector>
#include <cstdio>
#include <cstring>
using namespace std;

#define maxn 40005
#define pb push_back
struct Edge {
    int v,w;
    Edge(int a=0,int b=0):v(a),w(b){}
};
vector<Edge> G[maxn];
int dis[maxn];

struct LCA {
    int an[maxn][16],dep[maxn],n;
    void init(int a) {
        n=a;
        for(int i=1;(1<<i)<=n;++i)
            for(int j=1;j<=n;++j)
                an[j][i]=-1;
    }
    void pre() {
        dep[1]=dis[1]=0;
        dfs(1,-1);
        for(int j=1;(1<<j)<=n;++j)
            for(int i=1;i<=n;++i)
                an[i][j]=an[an[i][j-1]][j-1];
    }
    void dfs(int p,int fa) {
        an[p][0]=fa;
        for(int i=0;i<G[p].size();++i) {
            int v=G[p][i].v,w=G[p][i].w;
            if(v==fa) continue;
            dep[v]=dep[p]+1;
            dis[v]=dis[p]+w;
            dfs(v,p);
        }
    }
    int query(int p,int q) {
        if(dep[p]<dep[q]) swap(p,q);
        int i,j;
        for(i=0;(1<<i)<=dep[p];++i);
        --i;
        for(j=i;~j;--j)
            if(dep[p]-(1<<j)>=dep[q])
                p=an[p][j];
        if(p==q) return p;
        for(j=i;~j;--j)
            if(~an[p][j]&&an[p][j]!=an[q][j])
                p=an[p][j],q=an[q][j];
        return an[p][0];
    }
}lca;

int main() {
    int T,n,m;
    scanf("%d",&T);
    while(T--) {
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;++i) G[i].clear();
        for(int i=1;i<n;++i) {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            G[u].pb(Edge(v,w));
            G[v].pb(Edge(u,w));
        }
        lca.init(n);
        lca.pre();
        for(int i=1;i<=m;++i) {
            int u,v;
            scanf("%d%d",&u,&v);
//            cout << lca.query(u,v) << endl;
            printf("%d\n",dis[u]+dis[v]-2*dis[lca.query(u,v)]);
        }
    }
    return 0;
}