LCA是啥呢，LCA就是一棵樹裡兩個節點的最近公共祖先，如下圖

2號節點和3號節點的LCA就是1, 5號節點和11號節點的LCA就是2，8號節點和4號節點的lca就是4

那麼怎麼求LCA呢。首先要建樹，然後最容易想到的就是兩個節點一起向上跳，第一個相遇的節點就是LCA

輸入輸出格式可參考洛谷P3379 LCA模板題

輸入格式：

第一行包含三個正整數N、M、S，分別表示樹的結點個數、詢問的個數和樹根結點的序號。

接下來N-1行每行包含兩個正整數x、y，表示x結點和y結點之間有一條直接連線的邊（資料保證可以構成樹）。

接下來M行每行包含兩個正整數a、b，表示詢問a結點和b結點的最近公共祖先。

輸出格式：

輸出包含M行，每行包含一個正整數，依次為每一個詢問的結果。

先用鄰接表存路徑。

void add(int x,int y)
{
    to[++cnt]=y;
    nxt[cnt]=head[x];
    head[x]=cnt;
}

int main()
{
    n=read();m=read();s=read();
    int i,x,y;
    for(i=1;i<n;i++)
    {
        x=read();y=read();
        add(x,y);
        add(y,x);
    }
    return 0;
}
 

存路徑後，我們用dfs建樹，把每個節點的深度記錄下來

void dfs(int x,int fa)//fa表示父節點編號
{
    int i;
    f[x]=fa;//f[x]表示x節點的父節點
    d[x]=d[fa]+1;
    for(i=head[x];i;i=nxt[i])
        if(to[i]!=fa)
            dfs(to[i],x);
}

其次需要先把兩個節點跳到同一深度，然後一起往上跳即可

int work(int x,int y)
{
    int i;
    if(d[x]<d[y])
        swap(x,y);
    while(d[x]>d[y])
    	x=f[x];//移動至同一深度
    while(x!=y)
    	x=f[x],y=f[y];
    return x;
}
 

以上就是暴力求LCA，以為能AC嗎？？妥妥的TLE！！！

那麼為什麼Ｔ呢？是因為一次只移動到父親節點要跳好多次，這樣太慢了！

那麼怎麼才能快點呢？就要用倍增了！設一個grd[x][i]陣列表示x節點想上跳2的i次方後的節點。所以i<=log2(n)

這個陣列怎麼用呢？令d[x]>=d[y]。首先還是要跳到同一深度中，先讓x跳2^20次（最大）。假設我們發現深度比y小了，這就表示跳過了，我們再試試跳2^19次，如果還過了，那就再變小。如果發現深度還沒到，那就跳唄，接著我們再跳，就該試試跳2^18次了，為什麼不能跳兩個2^19次呢？這是以為兩個2^19次就是2^20次啊，肯定可以不用跳兩次相同的。這樣跳就能大大減少時間了。

到同一深度後，就是兩個點一起往上跳了。我們還是讓兩個點跳2^20次，如果發現跳完後相同了，就可以確定跳到祖先了，但不一定是最近的，所以我們先不著急跳，接著，試試跳2^19次，如果還是相同，那就再變小，如果不相同，那就跳（跟上面差不多），最後跳完，可以確定x和y再向上跳一次就是LCA了，因為我們跳的時候判定了如果跳之後相同那就不跳。但是注意，當y是x的祖先時，跳到同一深度時x==y已經是LCA了，此時就不用再往上跳了。

舉個栗子，還是剛才那張圖，我們模擬一下求11和7的LCA                                                                                                               

首先移動到同一深度，d[7]=3，d[11]=4，所以我們從2^20次（最大）開始，一直到2^1都不行，所以節點11跳了2^0次跳到了節點6。

接著兩個節點一塊兒跳，從2^20次，最後還是隻能跳2^0次，變成了節點2和節點3，最終再跳一次即節點1就是LCA。

em……這個栗子有點小。。。。。。。

好了，那怎麼預處理grd陣列呢？我們可以在dfs建樹的時候預處理，那麼我們可以確定grd[x][0]就是他的爸爸，那麼怎麼確定grd[x][1]呢？grd[x][1]不就是爸爸的爸爸（爺爺）嘛，所以grd[x][1]=grd [ grd [ x ] [ 0 ] ] [ 0 ]（為了讓大家看清楚特意用空格隔開嘿嘿嘿），那麼grd[x][2]呢（注意這是爺爺的爺爺，而不是爺爺的爸爸）？爺爺的爺爺不就等於grd [ grd [ x ] [ 1 ] ] [ 1 ]嘛。

以此類推，我們得出grd[x][i]=grd[ grd [ x ] [ i - 1 ] ] [ i - 1 ]。是因為2^(i-1)+2(i-1)=2^i，即往上跳兩次2^(i-1)就是往上跳2^i

好了我們再捋一遍思路，鄰接表+預處理grd陣列+跳到相同深度+一起往上跳，程式碼如下。

#include <iostream>
#include <cstdio>
#include <cctype>
#include <cstring>

using namespace std;

inline int read()
{
    int f=1,x=0;
    char c=getchar();
    while(!isdigit(c)){if(c=='-')f*=-1;c=getchar();}
    while(isdigit(c)){x=x*10+c-'0';c=getchar();}
    return x*f;
}

const int N=5e5+5;
int a[N],n,m,s,to[N<<1],head[N],nxt[N<<1],grd[N][23],d[N],cnt;

void add(int x,int y)
{
    to[++cnt]=y;
    nxt[cnt]=head[x];
    head[x]=cnt;//鄰接表
}

void dfs(int x,int fa)
{
    int i;
    grd[x][0]=fa;//父節點
    d[x]=d[fa]+1;
    for(i=1;i<21;i++)//其實到本題19就可以了，習慣到20整一點哈哈哈
        grd[x][i]=grd[grd[x][i-1]][i-1];//預處理grd陣列
    for(i=head[x];i;i=nxt[i])
        if(to[i]!=fa)
            dfs(to[i],x);
}

int lca(int x,int y)
{
    int i;
    if(d[x]<d[y])
        swap(x,y);
    for(i=20;i>=0;i--)//從大到小列舉
        if((1<<i)<=d[x]-d[y])//1<<i就是2^i,也可以預處理成陣列
            x=grd[x][i];
    if(x==y)
        return x;//當y是x的祖先時
    for(i=20;i>=0;i--)
        if(grd[x][i]!=grd[y][i])
            x=grd[x][i],y=grd[y][i];//一起往上跳
    return grd[x][0];//返回父節點
}

int main()
{
    n=read();m=read();s=read();
    int i,j,x,y;
    for(i=1;i<n;i++)
    {
        x=read();y=read();
        add(x,y);
        add(y,x);//鄰接表
    }
    dfs(s,0);//預處理
    for(i=1;i<=m;i++)
    {
        x=read();y=read();
        printf("%d\n",lca(x,y));
    }
    return 0;
}

當然，遇到相應的題可再加陣列，比如有時可定義dis[x][i]表示x節點向上跳2^i的距離（權），或者表示最大最小值等。