LCA的在线算法， DFS编号 + ST来rmq。

先讲讲 rmq的dp思想：
加入A[i] 是我们要求区间最值的数列，F[i,j]表示从第i个数起连续2^j 个数中的最大值。
例如： A : 3 2 4 5 6 8 1 2 9 7
F[1,0] 表示从第一个数开始长度为2^0=1 的最大值， 就是三这个数。同理F[1,1]=max(3,2)=3;
F[1，2]=max(3,2,4,5)=5………..且F[i,0]=i;
初值已经有了, 求F[i,j] 长度 肯定是偶数， 所以最大值用dp 来想就是分为两段，就是两段中的max就是结果，于是我们可以很巧妙地得到状态转移方程： F[i , j] = max(F[i, j-1] , F[i+ 2^(j-1) , j-1]) ;
代码：

void RMQ(int num){
    for(int j=1; j<20 ;j++)
       for(int i=1;i<=num;i++)
           if(i+ (1<<j)-1 <= num){
              maxsum[i][j]= max(maxsum[i][j-1] , maxsum[i+ (1<<(j-1)) ][j-1]);
              minsum[i][j]= min(minsum[i][j-1] , minsum[i+ (1<<(j-1)) ][j-1]);
           }
}

这里我们可以注意到：
第j 层的状态 需要 j-1 层的状态来转移。
所以 这个 j的for循环 必然要放到最外面。
至于查询 rmq（i , j）
我们知道长度为 j-i+1 , 所以 我们可以取 k= log2 (j - i + 1) ，则RMQ(A , i ,j)=max(F[I,K],F[j-2^k +1,k ] ) ;

在LCA上面：
我们假设无线图是树，我们找一个根 ，开始dfs，
用 F 记录每一个节点。
用rmq记录 每一个节点的深度。
用first记录每一个节点在F中第一次出现的坐标。
先dfs 得到 rmq，F
然后我们对F 序列进行 rmq 的dp操作，因为之前记录 这个dp存在F中的下标即可。

然后我们直接查询就好：
模板 ：

/*
 * LCA 在线算法：dfs +ST(RMQ)
 * poj 1330 裸题
 */
#include <cstdio>
#include <cmath>
#include <cstring>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <sstream>
#include <queue>
#include <typeinfo>
#include <fstream>
#include <map>
#include <stack>
typedef long long ll;
using namespace std;

const int MAXN=10010;
int rmq[2*MAXN]; //rmq数组, 记录每个节点在树中的深度
struct ST{
    int mm[2*MAXN];
    int dp[2*MAXN][20]; //dp 直接存下标
    void init(int n){
        mm[0]=-1;
        for(int i=1;i<=n;i++){
            mm[i]=((i&(i-1))==0)? mm[i-1]+1 :mm[i-1]; //???莫名其妙定义长度
            dp[i][0]=i; //初始化dp数组
        }
        for(int j=1;j<=mm[n];j++)   //可以看出来mm[n] 就是一个长度为n的序列j的最大值
            for(int i=1;i+(1<<j)-1 <=n ; i++){
                if(rmq[dp[i][j-1]] < rmq[dp[i+(1<<(j-1))][j-1] ]){
                    dp[i][j]=dp[i][j-1];
                }
                else
                    dp[i][j]=dp[i+(1<<(j-1))][j-1];
            }
    }
    int query(int a,int b){  //这个询问返回的是位置pos， F[pos]才是值
            if(a>b)
                swap(a,b);
            int k=mm[b-a+1];
            if(rmq[dp[a][k]] <= rmq[dp[b-(1<<k)+1][k]] ){
                return dp[a][k];
            }
            else
                return dp[b-(1<<k)+1][k];
    }
};
struct Edge{
    int to,next;
    int w; // 用w来记录权值：即到根部的距离。
};
Edge edge[MAXN*2];
int tot,head[MAXN];
int F[MAXN*2];   // 按顺序存储节点 ，下标从1开始,长度为2*n-1
int first[MAXN]; // i在F中第一次出现的位置
int cnt;
//int dir[N];      //保存每个点到树根的距离，很多问题中树边都有权值，会询问两点间的距离，
//如果树边没权值，相当于权值为1
ST st;
void init(){
    tot=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v){ //无向边自然加两次
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void dfs(int u,int pre,int dep){ //u起点，dep表示深度
     F[++cnt] = u;    // cnt就是这个节点的下标
     rmq[cnt]=dep;    //rmq记录节点在树中的深度
     first[u]=cnt;       //这个first 不会被更新掉,因为我们把continue了回去的路
     for(int i=head[u];i!=-1; i=edge[i].next){
         int v=edge[i].to;
         if(v==pre) continue;
//       dir[v]=dir[u] + edge[i].w;
         dfs(v,u,dep+1);
         F[++cnt] = u;     //虽然continue回去的路，但是询问叶子节点还要返回：1-2-1 --....
         rmq[cnt] = dep;
     }
}
void LCA_init(int root ,int node_num){ //查询LCA前的初始化
    cnt=0;
    dfs(root,root,0);
    st.init(2*node_num-1); // 注意 ，这里dp的不是n，而是对F进行dp
}
int query_lca(int u,int v){   //查询lca(u,v)
    return F[st.query(first[u],first[v])];
}
bool flag[MAXN];
int main(){
    //freopen("1.txt","r",stdin);
    int T;
    int N;
    int u,v;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&N);
        init();
        memset(flag,false,sizeof(flag));
        for(int i=1;i<N;i++){
            scanf("%d %d",&u,&v);
            addedge(u,v);
            addedge(v,u);
            flag[v]=true;
        }
        int root;
        for(int i=1;i<=N;i++)
            if(!flag[i]){ //某个根
                root=i;
                break;
            }
        LCA_init(root,N);
        scanf("%d %d",&u,&v);
        printf("%d\n",query_lca(u,v));
    }
    return 0;
}