tarjan离线求lca

lca即为最近公共祖先，通过dfs遍历一棵树即可无顺序地求出lca

思路：先找出根节点，用有向边连树，进行dfs，因为每个节点最多被遍历一次，因此复杂度为O（n）；

运用并查集，在遍历子树的时候将子树中所有的元素连接到子树的根节点上，此处需要用到并查集，因为并查集时间复杂度极小。

注意，是在回溯时才进行连接，因为如果在遍历时进行，则无法查到现在的lca，因为所有的节点都被连接在了第一个根节点上，

这样就求不出来了。为什么可行？

因为两个节点要么分别在两颗子树上，要么为祖先关系，当分别在两颗子树上时，遍历到其中一个点时，其lca还没有回溯，因此

可以查到其lca。第二种，则其中一点为另外一点根节点，只要两个点都被标记成访问，则其lca连回溯都没有回溯，直接返回就可

以了。

代码：

#include <set>
#include <map>
#include <queue>
#include <deque>
#include <cstdio>
#include <string>
#include <vector>
#include <math.h>
#include <time.h>
#include <utility>
#include <cstdlib>
#include <sstream>
#include <cstring>
#include <stdio.h>
#include <iomanip>
#include <iostream>
#include <algorithm>
using namespace std;
int n,t,x,y,u,v;
vector<int>graph[10010];
int father[10010],rank[10010],used[10010],out[10010];
bool flag;
int find(int x)
{
    if(x!=father[x])
    {
        father[x]=find(father[x]);
    }
    return father[x];
}
void connect(int x,int y)
{
    int a=find(x);
    int b=find(y);
    if(a==b)return;
    if(rank[a]>=rank[b])
    {
        rank[a]+=rank[b];
        father[b]=a;
    }
    else
    {
        rank[b]+=rank[a];
        father[a]=b;
    }
}
void tarjan(int u)
{
    if(flag)
    {
        return;
    }
    used[u]=1;
    for(int i=0;i<graph[u].size();i++)
    {
        int v=graph[u][i];
        tarjan(v);
        if(flag)return;
        connect(u,v);
        father[find(u)]=u;
        father[u]=u;
    }
    used[u]=1;
    if(u==x&&used[y])
    {
        printf("%d\n",find(y));
        flag=true;
        return;
    }
    if(u==y&&used[x])
    {
        printf("%d\n",find(x));
        flag=true;
        return;
    }
}
int main()
{
    cin>>t;
    while(t--)
    {
        flag=false;
        cin>>n;
        memset(father,0,sizeof(father));
        memset(rank,0,sizeof(rank));
        memset(used,0,sizeof(used));
        memset(out,0,sizeof(out));
        for(int i=1;i<=n;i++)
        {
            father[i]=i;
            rank[i]=1;
        }
        for(int i=1;i<n;i++)
        {
            cin>>u>>v;
            out[v]++;
            graph[u].push_back(v);
        }
        cin>>x>>y;
        for(int i=1;i<=n;i++)
        {
            if(!out[i])
            {
                tarjan(i);
                break;
            }
        }
        for(int i=1;i<=n;i++)
        {
            graph[i].clear();
        }
    }
    return 0;
}