Nearest Common Ancestors--POJ 1330

1、题目类型：LCA、并查集、DFS。

2、解题思路：最近公共祖先(Least Common Ancestors)：对于有根树T的两个结点u、v，最近公共祖先LCA(T,u,v)表示一个结点x，满足x是u、v的祖先且x的深度尽可能大。步骤，（1）构造树形结构；（2）用并查集的方法求解LCA，DFS深度搜索树，搜索过程中记录其father节点，直到询问的两个节点找到为止；（3）由于此题只是询问一对节点的最近公共祖先，所以用flag记录其询问是否完成，可以减少运算时间。

3、注意事项：注意LCA函数、Find函数这种递归调用方式。

4、实现方法:

  
    

   
     
   
     #include
   
     <
   
     iostream
   
     >
   
     
#include
   
     <
   
     vector
   
     >
   
     

   
     #define
   
      MAX 10010
   
     

   
     using
   
      
   
     namespace
   
      std;


   
     int
   
      n,flag;

   
     int
   
      f[MAX],r[MAX],ancestor[MAX];

   
     int
   
      indegreen[MAX],vis[MAX];
vector
   
     <
   
     int
   
     >
   
      head[MAX],Que[MAX];


   
     void
   
      Init()
{
 
   
     int
   
      i,a,b;
 cin
   
     >>
   
     n;
 flag
   
     =
   
     0
   
     ;
 
   
     for
   
     (i
   
     =
   
     1
   
     ;i
   
     <=
   
     n;i
   
     ++
   
     )
 {
 head[i].clear();
 Que[i].clear();
 f[i]
   
     =
   
     i;
 r[i]
   
     =
   
     1
   
     ;
 ancestor[i]
   
     =
   
     0
   
     ;
 indegreen[i]
   
     =
   
     0
   
     ;
 vis[i]
   
     =
   
     0
   
     ;
 }
 
   
     for
   
     (i
   
     =
   
     1
   
     ;i
   
     <
   
     n;i
   
     ++
   
     )
 {
 cin
   
     >>
   
     a
   
     >>
   
     b;
 head[a].push_back(b);
 indegreen[b]
   
     ++
   
     ;
 }
 cin
   
     >>
   
     a
   
     >>
   
     b;
 Que[a].push_back(b);
 Que[b].push_back(a);
}


   
     int
   
      Find(
   
     int
   
      u)
{
 
   
     if
   
     (f[u]
   
     ==
   
     u)
 
   
     return
   
      f[u];
 
   
     else
   
     
 f[u]
   
     =
   
     Find(f[u]);
 
   
     return
   
      f[u];
}


   
     void
   
      Union(
   
     int
   
      v,
   
     int
   
      u)
{
 
   
     int
   
      a,b;
 a
   
     =
   
     Find(v);
 b
   
     =
   
     Find(u);
 
   
     if
   
     (a
   
     ==
   
     b)
 
   
     return
   
      ; 
 
   
     if
   
     (r[a]
   
     <=
   
     r[b])
 {
 f[a]
   
     =
   
     b;
 r[b]
   
     +=
   
     r[a];
 }
 
   
     else
   
     
 {
 f[b]
   
     =
   
     a;
 r[a]
   
     +=
   
     r[b];
 }
}


   
     void
   
      LCA(
   
     int
   
      k)
{
 
   
     int
   
      i,size;
 size
   
     =
   
     head[k].size();
 ancestor[k]
   
     =
   
     k; 
 
   
     for
   
     (i
   
     =
   
     0
   
     ;i
   
     <
   
     size;i
   
     ++
   
     )
 {
 
   
     if
   
     (flag)
 
   
     break
   
     ;
 LCA(head[k][i]);
 Union(k,head[k][i]);
 ancestor[Find(k)]
   
     =
   
     k;
 }
 vis[k]
   
     =
   
     1
   
     ; 
 size
   
     =
   
     Que[k].size();
 
   
     for
   
     (i
   
     =
   
     0
   
     ;i
   
     <
   
     size;i
   
     ++
   
     )
 {
 
   
     if
   
     (vis[Que[k][i]])
 {
 flag
   
     =
   
     1
   
     ;
 cout
   
     <<
   
     ancestor[Find(Que[k][i])]
   
     <<
   
     endl;
 
   
     return
   
      ;
 }
 }
}


   
     int
   
      main()
{
 
   
     int
   
      T;
 cin
   
     >>
   
     T;
 
   
     while
   
     (T
   
     --
   
     )
 {
 Init();
 
   
     for
   
     (
   
     int
   
      i
   
     =
   
     1
   
     ;i
   
     <=
   
     n;i
   
     ++
   
     )
 {
 
   
     if
   
     (
   
     !
   
     indegreen[i])
 {
 LCA(i);
 
   
     break
   
     ;
 }
 }
 }
 
   
     return
   
      
   
     0
   
     ;
}