poj1330Nearest Common Ancestors 1470 Closest Common Ancestors（LCA算法）

LCA思想：http://www.cnblogs.com/hujunzheng/p/3945885.html

在求解最近公共祖先为问题上，用到的是Tarjan的思想，从根结点开始形成一棵深搜树，非常好的处理技巧就是在回溯到结点u的时候，u的子树已经遍历，这时候才把u结点放入合并集合中，
这样u结点和所有u的子树中的结点的最近公共祖先就是u了，u和还未遍历的所有u的兄弟结点及子树中的最近公共祖先就是u的父亲结点。以此类推。。这样我们在对树深度遍历的时候就很自然的将树中的结点分成若干的集合，两个集合中的所属不同集合的任意一对顶点的公共祖先都是相同的，也就是说这两个集合的最近公共最先只有一个。对于每个集合而言可以用并查集来优化，时间复杂度就大大降低了，为O(n + q)，n为总结点数，q为询问结点对数。

 /*
     题意很明显，就是求LCA!
 */
 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<vector>
 #define N 10005
 using namespace std;

 int n;
 int x, y;
 vector<int>g[N];
 int f[N];
 int vis[N], cnt[N];
 int ret;

 int getFather(int x){
    return x==f[x] ? x : f[x]=getFather(f[x]);
 }

 bool LCA(int u){
     vis[u]=;
     f[u]=u;
     int len=g[u].size();

     if(u==x && vis[y]){
         ret=getFather(y);
         return true;
     }

     else if(u==y && vis[x]){
         ret=getFather(x);
         return true;
     }

     for(int i=; i<len; ++i){
         int v=g[u][i];
         if(!vis[v]){
             if(LCA(v)) return true;
             f[v]=u;
         }
     }
     return false;
 }

 int main(){
     int t;
     scanf("%d", &t);
     while(t--){
         scanf("%d", &n);
         memset(cnt, , sizeof(cnt));
         for(int i=; i<n; ++i){
             int u, v;
             scanf("%d%d", &u, &v);
             g[u].push_back(v);
             ++cnt[v];
         }
         memset(vis, , sizeof(vis));
         scanf("%d%d", &x, &y);
         for(int i=; i<=n; ++i)
             if(cnt[i]==){
                 LCA(i);
                 break;
             }
         printf("%d\n", ret);
         for(int i=; i<=n; ++i)
             g[i].clear();
     }
     return ;
 }
  

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<algorithm>
 #include<vector>
 #define N 905
 #define M 25000
 using namespace std;

 vector<int>g[N];
 vector<int>p[M];
 int cnt[N];
 int f[N];
 int vis[N];
 int ans[N];

 int n, m;

 int getFather(int x){
    return x==f[x] ? x : f[x]=getFather(f[x]);
 }

 void LCA(int u){
     f[u]=u;
     vis[u]=;
     int len;

     len=p[u].size();
     for(int i=; i<len; ++i){
         int v=p[u][i];
         if(vis[v])
               ++ans[getFather(v)];
     }

     len=g[u].size();
     for(int i=; i<len; ++i){
            int v=g[u][i];
            if(!vis[v]){
             LCA(v);
             f[v]=u;
         }
     }
 }

 int main(){
       while(scanf("%d", &n)!=EOF){
             memset(cnt, , sizeof(cnt));
           for(int i=; i<=n; ++i){
                   vis[i]=;
                   ans[i]=;
                   int a, d, b;
                   char ch;
                   scanf("%d", &a);
                   while(scanf("%c", &ch) && ch!='(');
                   scanf("%d", &d);
                   while(scanf("%c", &ch) && ch!=')');
                   while(d--){
                    scanf("%d", &b);
                    ++cnt[b];
                    g[a].push_back(b);
                 }
           }
           scanf("%d", &m);
           while(m--){
                char ch;
              while(scanf("%c", &ch) && ch!='(');
              int u, v;
              scanf("%d%d", &u, &v);
              p[u].push_back(v);
              p[v].push_back(u);
              while(scanf("%c", &ch) && ch!=')');
           }

           for(int i=; i<=n; ++i)
              if(cnt[i]==){
                 LCA(i);
                 break;
             }
          for(int i=; i<=n; ++i)
             if(ans[i]!=)
                 printf("%d:%d\n", i, ans[i]);

          for(int i=; i<=n; ++i)
             g[i].clear(), p[i].clear();
     }
     return ;
 }