找最近公共父節點這問題很容易想到讓兩節點一起往上走最後相遇，但這樣的dfs顯然很慢，於是就需要倍增。就是用二進位制的思維，以1,2,4,8等2的階層步長接近答案，比一步一步向上要快很多。
所以要dfs出來點的2^k的父親節點與該節點的深度。
找lca時先將下面的點升到與另一點同一深度，再用往上倍增找lca。
有兩種大同小異的方法：一種是以上一步2倍長的步伐向上試，不行再縮減，找到一個離lca能達到的最近點。另一種是先求出最大深度是2的幾次方，再以當前最大步伐向上走。具體看下面程式碼，喜歡哪種打哪種。。。
簡單一題hdu2586
大意是求兩節點距離，只用在dfs時求從根到節點的距離，用L=dis[i]+dis[j]-2*dis[lca(i+j)]求出。
以下程式碼：

#include<stdio.h>
#include<algorithm>
#include<string.h>

using namespace std;

const int maxn=40005;

int tot;
int a[maxn],b[maxn*2],c[maxn*2],w[maxn*2],deep[maxn],dis[maxn],fa[maxn][16];   //注意邊要兩倍空間 
bool bo[maxn];

void setin(int x,int y,int z)           //鄰接表儲存圖 
{
    b[++tot]=a[x];
    a[x]=tot;
    c[tot]=y;
    w[tot]=z;
}

void
 
 dfs(int x)                         //預處理 
{
    int p,son;
    p=a[x];
    while(p)
    {        
        son=c[p];
        if(!bo[son])
        {
            bo[son]=true;                 //避免走回去 
            fa[son][0]=x;
            deep[son]=deep[x]+1;
            dis[son]=dis[x]+w[p];
            int
 
 ii=0,po=x;
            while(fa[po][ii]!=0)
            {
                fa[son][ii+1]=fa[po][ii];  
                po=fa[po][ii++];          //關鍵！父節點相當於每次*2，來更新這個子節點的2^k父節點，自己模擬就明白了 
            }
            dfs(son);
        }
        p=b[p];
    }
}

int lca(int x,int y)
{

    if(x==y) return x;
    if(deep[x]<deep[y]) swap(x,y);
    int m=deep[x]-deep[y],ii=0;
    while(m)                              //m表示為二進位制，以2,4,8等步伐向上 
    {
        if(m&1==1) x=fa[x][ii];
        m>>=1;
        ii++;
    }
    ii=0;
    while(x!=y)
      if(fa[x][ii]!=fa[y][ii]||((fa[x][ii]==fa[y][ii])&&(ii==0)))  //條件很關鍵，僅有一步時要走才能退出迴圈 
      {
          x=fa[x][ii];
          y=fa[y][ii];
          ii++;
      }
      else ii--;
    return x;  
}
int main()
{
    int t,n,q,x,y,z;
    scanf("%d",&t);
    for(int i=0;i<t;i++)
    {
        tot=0;
        memset(a,0,sizeof(a));
        memset(b,0,sizeof(b));
        memset(c,0,sizeof(c));
        memset(w,0,sizeof(w));
        memset(deep,0,sizeof(deep));
        memset(dis,0,sizeof(dis));
        memset(fa,0,sizeof(fa));
        memset(bo,0,sizeof(bo));        
        scanf("%d%d",&n,&q);
        for(int j=0;j<n-1;j++)
        {
            scanf("%d%d%d",&x,&y,&z);
            setin(x,y,z);
            setin(y,x,z);
        }
        deep[1]=1;
        dis[1]=0;
        bo[1]=true;
        dfs(1);
        for(int j=0;j<q;j++)
        {
            scanf("%d%d",&x,&y);
            printf("%d\n",dis[x]+dis[y]-2*dis[lca(x,y)]);
        }
    }
}

另一種lca求法：

int lca(int x,int y)
{
    int i,j;
    if(deep[x]<deep[y])swap(x,y);
    for(i=0;(1<<i)<=deep[x];i++);   //求深度是2的幾次方，給下面迴圈找上界 
    i--;
    for(j=i;j>=0;j--)
        if(deep[x]-(1<<j)>=deep[y])
            x=fa[x][j];             //另一種將x提到與y同高度的寫法 
    if(x==y)return x;
    for(j=i;j>=0;j--)
    {
        if(fa[x][j]!=fa[y][j])
        {
            x=fa[x][j];
            y=fa[y][j];
        }
    }
    return fa[x][0];   //注意是把2^k拆成1和其他2的次方，所以返回父節點 
}

ps:因為並不會vector釋放記憶體，就寫了一大串memset，求大神指教如何簡化。