LCA倍增法模板

deg其实应该写成depth吧，存的是每个结点的深度，dfs的过程是为了处理出每个结点的深度，用递推式计算出fa[u][i],其中f[u][i]表示u的第2^i个祖先；
 基本思想是：
 d[i] 表示 i节点的深度, p[i,j] 表示 i 的 2^j 倍祖先
 那么就有一个递推式子 p[i,j]=p[p[i,j-1],j-1] 　　
 这样子一个O(NlogN)的预处理求出每个节点的 2^k 的祖先 　　
 然后对于每一个询问的点对a, b的最近公共祖先就是： 　
 　
 先判断是否 d[x] < d[y] ,如果是的话就交换一下(保证 x 的深度大于 y 的深度)
 然后把 x 调到与 y 同深度, 同深度以后再把a, b 同时往上调,调到有一个最小的j
 满足p[x,j]!=p[y,j] (x,y是在不断更新的), 最后再把(x,y)往上调 (x=p[x,0], y=p[y,0])

 一个一个向上调直到x = y, 这时 x或y 就是他们的最近公共祖先

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>

using namespace std;
const int maxn=200020;
int head[maxn],tol,deg[maxn],fa[maxn][23];
struct node 
{
      int next,to;
}edge[20*maxn];
void add(int u,int v)
{
      edge[tol].to=v;
      edge[tol].next=head[u];
      head[u]=tol++;
}
void dfs(int u,int pre)
{
      deg[u]=deg[pre]+1;
      fa[u][0]=pre;
      for(int i=1;i<23;i++)fa[u][i]=fa[fa[u][i-1]][i-1];
      for(int i=head[u];i!=-1;i=edge[i].next)
      {
	     int v=edge[i].to;
	     if(v==pre)continue;
	     dfs(v,u);
      }
}
int lca(int x,int y)
{
      if(deg[x]<deg[y])swap(x,y);
      for(int i=0;i<22;i++)if((deg[x]-deg[y])&(1<<i))x=fa[x][i];
      if(x==y)return x;
      for(int i=22;i>=0;i--)if(fa[x][i]!=fa[y][i])x=fa[x][i],y=fa[y][i];
      return fa[x][0];
}

int main()
{
      int i,j,k,m,n;
     // freopen("data.in","r",stdin);
    //  freopen("data.out","w",stdout);
      while(cin>>n>>m)
      {
	     memset(head,-1,sizeof(head));tol=0;
	     for(i=1;i<n;i++)
	     {
		    cin>>j>>k;
		    add(j,k);
		    add(k,j);
	     }
	     dfs(1,1);
	    // for(i=1;i<=n;i++)cout<<deg[i]<<" ";cout<<endl;
           while(m--)
	    {
		   cin>>i>>j;
		   cout<<lca(i,j)<<endl;
	    }
      }
      return 0;
}