树链剖分 求lca

代码量小，还可以结合树剖快速搞事…………
简单的写了一下，只要了解了树剖思想一般都能写出来

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=500011;
int sz[MAXN],fst[MAXN],nxt[MAXN],son[MAXN],top[MAXN];
int fa[MAXN],deep[MAXN];
int totp,n,tot;
struct hh {int from,to;}ma[MAXN];
void build(int f,int t)
{
    tot++;
    ma[tot]=(hh){f,t};
    nxt[tot]=fst[f];
    fst[f]=tot;
    return;
}
void dfs1(int u,int f)
{
    fa[u]=f;
    deep[u]=deep[f]+1;
    sz[u]=1;
    for(int i=fst[u];i;i=nxt[i])
    {
        int v=ma[i].to;
        if(v==f) continue;
        dfs1(v,u);
        sz[u]+=sz[v];
        if(!son[u] || sz[v]>sz[son[u]]) son[u]=v;
    }
    return;
}
void dfs2(int x,int st)
{
    top[x]=st;
    if(!son[x]) return;
    dfs2(son[x],st);
    for(int i=fst[x];i;i=nxt[i])
    {
        int v=ma[i].to;
        if(v==fa[x] || v==son[x]) continue;
        dfs2(v,v);
    }
    return;
}
int lca(int x,int y)
{
    int fx=top[x],fy=top[y];
    while(fx!=fy)
    {
        if(deep[fx]<deep[fy]) swap(x,y),swap(fx,fy);
        x=fa[fx],fx=top[x];
    }
    return deep[x]<deep[y]?x:y; 
}
void solve()
{
    int q,x,y;
    cin>>n;
    for(int i=1;i<n;i++) cin>>x>>y,build(x,y),build(y,x);
    dfs1(1,0),dfs2(1,1);
    cin>>q;
    while(q--)
    {
        cin>>x>>y;
        cout<<lca(x,y)<<endl;
    }
}
int main()
{
    solve();
    return 0;
}

例题 ： 小机房的树codevs2370

树链剖分：

比倍增求lca稍快一点点（10ms以内）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=500011;
int sz[MAXN],fst[MAXN],nxt[MAXN],son[MAXN],top[MAXN],rank[MAXN];
int fa[MAXN],deep[MAXN];
int totp,n,tot,q;
struct hh {int from,to,cost;}ma[MAXN];
void build(int f,int t,int c)
{
    tot++;
    ma[tot]=(hh){f,t,c};
    nxt[tot]=fst[f];
    fst[f]=tot;
    return;
}
void dfs1(int u,int f,int c)
{
    fa[u]=f;
    rank[u]=c;
    deep[u]=deep[f]+1;
    sz[u]=1;
    for(int i=fst[u];i;i=nxt[i])
    {
        int v=ma[i].to;
        if(v==f) continue;
        dfs1(v,u,c+ma[i].cost);
        sz[u]+=sz[v];
        if(!son[u] || sz[v]>sz[son[u]]) son[u]=v;
    }
    return;
}
void dfs2(int x,int st)
{
    top[x]=st;
    if(!son[x]) return;
    dfs2(son[x],st);
    for(int i=fst[x];i;i=nxt[i])
    {
        int v=ma[i].to;
        if(v==fa[x] || v==son[x]) continue;
        dfs2(v,v);
    }
    return;
}
int lca(int x,int y)
{
    int fx=top[x],fy=top[y];
    while(fx!=fy)
    {
        if(deep[fx]<deep[fy]) swap(x,y),swap(fx,fy);
        x=fa[fx],fx=top[x];
    }
    return deep[x]<deep[y]?x:y; 
}
void solve()
{
    int x,y,c;
    cin>>n;
    for(int i=1;i<n;i++) scanf("%d%d%d",&x,&y,&c),build(x,y,c),build(y,x,c);
    dfs1(0,0,0),dfs2(0,0);
    cin>>q;
    while(q--)
    {
        scanf("%d%d",&x,&y);
        printf("%d\n",rank[x]+rank[y]-2*rank[lca(x,y)]);
    }
}
int main()
{
    solve();
    return 0;
}

倍增lca：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int MAXN=400001;
int tot,n,m,fst[MAXN],nxt[MAXN],deep[MAXN],fa[MAXN/2][20],rank[MAXN];
bool vis[MAXN];
struct hh
{
    int from,to,cost;
}ma[MAXN];
void build(int f,int t,int c)
{
    tot++;
    ma[tot]=(hh){f,t,c};
    nxt[tot]=fst[f];
    fst[f]=tot;
    return;
}
int lca(int x,int y)
{
    if(deep[x]<deep[y]) swap(x,y);
    int s=deep[x]-deep[y];
    for(int i=0;i<=19;i++)
        if(s & (1<<i))
            x=fa[x][i];
    if(x==y) return x;
    for(int i=19;i>=0;i--) 
        if(fa[x][i]!=fa[y][i]) x=fa[x][i],y=fa[y][i];
    return fa[x][0];
}
void dfs(int x,int c)
{
    vis[x]=1;
    rank[x]=c;
    for(int i=fst[x];i;i=nxt[i])
    {
        int v=ma[i].to;
        if(!vis[v])
        {
            fa[v][0]=x;
            deep[v]=deep[x]+1;
            dfs(v,ma[i].cost+c);
        }
    }
    return;
}
void make_lca()
{
    for(int i=1;i<=19;i++)
        for(int j=1;j<=n;j++) fa[j][i]=fa[fa[j][i-1]][i-1];
    return;
}
void solve()
{
    int f,t,c;
    cin>>n;
    for(int i=1;i<n;i++) scanf("%d%d%d",&f,&t,&c),build(f,t,c),build(t,f,c);
    dfs(0,0);
    make_lca();
    cin>>m;
    while(m--)
    {
        scanf("%d%d",&f,&t);
        printf("%d\n",rank[f]+rank[t]-2*rank[lca(f,t)]);
    }
    return;
}
int main()
{
    solve();
    return 0;
}