codevs 2370 小机房的树（lca）

题目描述 Description
小机房有棵焕狗种的树，树上有N个节点，节点标号为0到N-1，有两只虫子名叫飘狗和大吉狗，分居在两个不同的节点上。有一天，他们想爬到一个节点上去搞基，但是作为两只虫子，他们不想花费太多精力。已知从某个节点爬到其父亲节点要花费 c 的能量（从父亲节点爬到此节点也相同），他们想找出一条花费精力最短的路，以使得搞基的时候精力旺盛，他们找到你要你设计一个程序来找到这条路，要求你告诉他们最少需要花费多少精力

输入描述 Input Description
第一行一个n，接下来n-1行每一行有三个整数u，v, c 。表示节点 u 爬到节点 v 需要花费 c 的精力。
第n+1行有一个整数m表示有m次询问。接下来m行每一行有两个整数 u ，v 表示两只虫子所在的节点

输出描述 Output Description
一共有m行，每一行一个整数，表示对于该次询问所得出的最短距离。

样例输入 Sample Input
3
1 0 1
2 0 1
3
1 0
2 0
1 2

样例输出 Sample Output
1
1
2

数据范围及提示 Data Size & Hint
1<=n<=50000， 1<=m<=75000， 0<=c<=1000

题解：裸的lca，有好多种方法，可以记录儿子到父亲的距离，也可以记录到根节点的距离

2016.10.24：今天学了一下倍增lca，所以把这道题用倍增lca又做了一遍

代码如下:

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int MAXN=50000+500;
int first[MAXN],nxt[MAXN<<1];
int fa[MAXN],dis[MAXN],deep[MAXN]; 
bool used[MAXN];
int n,m,tot;
struct edge
{
    int from,to,cost;
}es[MAXN<<1];
void build(int f,int t,int d)
{
    es[++tot]=(edge){f,t,d};
    nxt[tot]=first[f];
    first[f]=tot;
}
void init()
{
    memset(first,-1,sizeof(first));
    tot=0;
}
void dfs(int s)//以s为根节点，建一棵树 
{
    for(int i=first[s];i!=-1;i=nxt[i])
    {
        int v=es[i].to;
        if(!used[v])
        {
            used[v]=1;
            dis[v]=es[i].cost;
            deep[v]=deep[s]+1;
            fa[v]=s;
            dfs(v);
        }
    }
}
int ask(int x,int y)
{
    int ans=0;
    if(deep[x]>deep[y]) swap(x,y);
    while(deep[x]!=deep[y])//深度不同，先放到同一深度 
    {
        ans+=dis[y];
        y=fa[y];
    }
    while(x!=y)//深度相同，一起向上移直到移到同一节点 
    {
        ans+=dis[x]+dis[y];
        x=fa[x];
        y=fa[y];
    }
    return ans;
}
int main()
{
    scanf("%d",&n);
    init();
    for(int i=1;i<=n-1;i++)
    {
        int ff,tt,dd;
        scanf("%d%d%d",&ff,&tt,&dd);
        build(ff,tt,dd);
        build(tt,ff,dd);
    }
    fa[0]=0;
    dfs(0);
    scanf("%d",&m);
    while(m--)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        printf("%d\n",ask(x,y));
    }
    return 0;
}

倍增lca：

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int MAXN=60000;
int first[MAXN],nxt[MAXN<<1];
int deep[MAXN],fa[MAXN],dis[MAXN];
int t[MAXN][30];//t[i][j]表示i向上跳2^j步能到达的点 
int n,m,tot;
bool used[MAXN];
struct edge
{
    int from,to,cost;
}es[MAXN<<1];
void init()
{
    memset(first,-1,sizeof(first));
    tot=0;
}
void build(int f,int t,int d)
{
    es[++tot]=(edge){f,t,d};
    nxt[tot]=first[f];
    first[f]=tot;
}
void dfs(int s)
{
    used[s]=1;
    for(int i=first[s];i!=-1;i=nxt[i])
    {
        int v=es[i].to;
        if(!used[v])
        {
            used[v]=1;
            dis[v]=dis[s]+es[i].cost;
            deep[v]=deep[s]+1;
            fa[v]=s;
            dfs(v);
        }
    }
}
int lca(int x,int y)
{
    if(deep[x]>deep[y]) swap(x,y);
    int tt=deep[y]-deep[x];//记录一下深度差 
    for(int i=0;i<=20;i++)
        if((1<<i)&tt) y=t[y][i];//将tt转化为二进制，如果当前位是一就跳 
    for(int i=20;i>=0;i--)
        if(t[x][i]!=t[y][i])//每次跳2的次方步，从大往小跳
        {
            x=t[x][i];
            y=t[y][i];
        }
    if(x!=y) return fa[x];//最后一定会跳到lca或lca的儿子 
    return x;
}
int main()
{
    init();
    scanf("%d",&n);
    for(int i=1;i<n;i++)
    {
        int u,v,c;
        scanf("%d%d%d",&u,&v,&c);
        build(u,v,c);
        build(v,u,c);
    }
    dfs(0);
    for(int i=0;i<n;i++)
        t[i][0]=fa[i];//初始化t[i][0]为i的父亲 
    for(int i=0;i<n;i++)
        for(int j=1;j<=20;j++)
            t[i][j]=t[t[i][j-1]][j-1];//向上跳2^j步等于先跳2^(j-1)步再跳2^(j-1)步 
    scanf("%d",&m);
    while(m--)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        int ans=lca(u,v);
        printf("%d\n",dis[u]+dis[v]-2*dis[ans]);
    }
    return 0;
}