Tarjan--LCA算法的个人理解即模板

tarjan---LCA算法的步骤是(当dfs到节点u时):

实际：  并查集+dfs

具体步骤：
1 在并查集中建立仅有u的集合,设置该集合的祖先为u
1 对u的每个孩子v:
   1.1 tarjan之
   1.2 合并v到父节点u的集合,确保集合的祖先是u
2 设置u为已遍历
3 处理关于u的查询,若查询(u,v)中的v已遍历过,则LCA(u,v)=v所在的集合的祖先。

举例子：

假设遍历完10的孩子,要处理关于10的请求了
取根节点到当前正在遍历的节点的路径为关键路径,即1-3-8-10
集合的祖先便是关键路径上距离集合最近的点
比如此时:
    1,2,5,6为一个集合,祖先为1,集合中点和10的LCA为1
    3,7为一个集合,祖先为3,集合中点和10的LCA为3
    8,9,11为一个集合,祖先为8,集合中点和10的LCA为8
    10,12为一个集合,祖先为10,集合中点和10的LCA为10
你看,集合的祖先便是LCA吧,所以第3步是正确的
道理很简单,LCA(u,v)便是根至u的路径上到节点v最近的点

此段话语来自sre="http://purety.jp/akisame/oi/TJU/"

模板：

 #include<iostream>
 #include<vector>
 using namespace std;

 const int MAX=;
 int father[MAX];
 int rank[MAX];
 int indegree[MAX];//保存每个节点的入度
 int visit[MAX];
 vector<int> tree[MAX],Qes[MAX];
 int ancestor[MAX];

 void init(int n)
 {
     for(int i=;i<=n;i++)
     {

         rank[i]=;
         father[i]=i;
         indegree[i]=;
         visit[i]=;
         ancestor[i]=;
         tree[i].clear();
         Qes[i].clear();
     }

 }

 int find(int n)
 {
     if(father[n]==n)
         return n;
     else
         father[n]=find(father[n]);
     return father[n];
 }//查找函数，并压缩路径

 int Union(int x,int y)
 {
     int a=find(x);
     int b=find(y);
     if(a==b)
         return ;
     //相等的话,x向y合并
     else if(rank[a]<=rank[b])
     {
         father[a]=b;
         rank[b]+=rank[a];
     }
     else
     {
         father[b]=a;
         rank[a]+=rank[b];
     }
     return ;

 }//合并函数，如果属于同一分支则返回0，成功合并返回1

 void LCA(int u)
 {
     ancestor[u]=u;
     int size = tree[u].size();
     for(int i=;i<size;i++)
     {
         LCA(tree[u][i]);
         Union(u,tree[u][i]);
         ancestor[find(u)]=u;
     }
     visit[u]=;
     size = Qes[u].size();
     for(int i=;i<size;i++)
     {
         //如果已经访问了问题节点,就可以返回结果了.
         if(visit[Qes[u][i]]==)
         {
             cout<<ancestor[find(Qes[u][i])]<<endl;
             return;
         }
     }
 }

 int main()
 {
     int cnt;
     int n;
     cin>>cnt;
     while(cnt--)
     {
         cin>>n;;
         init(n);
         int s,t;
         for(int i=;i<n;i++)
         {
             cin>>s>>t;
             tree[s].push_back(t);
             indegree[t]++;
         }
         //这里可以输入多组询问
         cin>>s>>t;
         //相当于询问两次
         Qes[s].push_back(t);
         Qes[t].push_back(s);
         for(int i=;i<=n;i++)
         {
             //寻找根节点
             if(indegree[i]==)
             {
                 LCA(i);
                 break;
             }
         }
     }
     return ;
 }