poj 1330 Nearest Common Ancestors

点击打开链接poj 1330

思路：LCA+离线Tarjan算法

分析：
1 LCA用于找到一棵树或者一个图中找到两个节点的最近的祖先问题。

2算法：
   1: Tarjan算法基于深度优先搜索的框架，对于新搜索到的一个结点，首先创建由这个结点构成的集合
   2: 再对当前结点的每一个子树进行搜索，每搜索完一棵子树，则可确定子树内的LCA询问都已解决。
   3: 其他的LCA询问的结果必然在这个子树之外，这时把子树所形成的集合与当前结点的集合合并，并将当前结点设为这个集合的祖先。
   4: 之后继续搜索下一棵子树，直到当前结点的所有子树搜索完。
   5: 这时把当前结点也设为已被检查过的，同时可以处理有关当前结点的LCA询问，如果有一个从当前结点到结点v的询问，且v已被检查过，则由于进行的是深度优先搜索，当前结点与v的最近公共祖先一定还没有被检查，而这个最近公共祖先的包涵v的子树一定已经搜索过了，那么这个最近公共祖先一定是v所在集合的祖先。

3实现：
1：图存在一个邻阶表里面  2：询问的两个点存在一个vector数组  3：如果有m次询问还要开一个结构体数组存储每一次询问的答案（因为求LCA的时候不是按照输入顺序询问的）  4：由于可能出现(x , y) x已经求完但是y没有这样所以就把(x , y) 和 (y , x)都加入，那么这样两次询问肯定有一次被接受
5：找到根节点一次LCA即可把所以的集合分开，然后就可以求出要询问的ans

代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<vector>
using namespace std;
#define MAXN 10010

int t , n , m;/*这里的m是指有m次询问*/
int l , r;
int ancestor[MAXN];
int father[MAXN];
int first[MAXN];
int next[MAXN];
int vis[MAXN];
int indegree[MAXN];
vector<int>v[MAXN];
struct Edge{
   int x;
   int y;
   int ans;
}e[MAXN];

/*初始化*/
void init(){
   for(int i = 1 ; i <= n ; i++){
       v[i].clear();
       father[i] = i;
   }
   memset(first , -1 , sizeof(first));
   memset(next , -1 , sizeof(next));
   memset(vis , 0 , sizeof(vis));
   memset(indegree , 0 , sizeof(indegree));
   memset(ancestor , 0 , sizeof(ancestor));
}

/*并查集的查找*/
int find_Set(int x){
    if(x != father[x])
      father[x] = find_Set(father[x]);
    return father[x];
}

/*并查集的合并*/
void union_Set(int x , int y){
    int root_x = find_Set(x);
    int root_y = find_Set(y);
    father[root_x] = root_y;
}


void LCA(int u){
     ancestor[u] = u;/*建立一个集合*/
     for(int i = first[u] ; i != -1 ; i = next[i]){
        LCA(i);
        union_Set(i , u);
        ancestor[find_Set(i)] = u;/*这里是i的根节点不是i*/
     }
     vis[u] = 1;/*把这个点标记为已经求过和它有关的LCA问题都可以知道*/
     for(int i = 0 ; i < v[u].size() ; i++){
        if(vis[v[u][i]]){ 
          int tmp = father[find_Set(v[u][i])];
          for(int j = 0 ; j < m ; j++){/*找到是那一条边询问*/
             if(e[j].x == u && e[j].y == v[u][i] || e[j].y == u && e[j].x == v[u][i])
                e[j].ans = tmp;
          }
        }
     }
}

int main(){
    int a , b;
    scanf("%d" , &t);
    while(t--){
        scanf("%d" , &n);
        init();
        m = 1;
        for(int i = 1 ; i < n ; i++){
           scanf("%d%d" , &a , &b);
           next[b] = first[a];
           first[a] = b;
           indegree[b]++;
        }
        for(int i = 0 ; i < m ; i++){
           scanf("%d%d" , &e[i].x , &e[i].y);
           v[e[i].x].push_back(e[i].y);/*加入(x , y)*/
           v[e[i].y].push_back(e[i].x);/*加入(y , x)*/
        }
        /*找到根节点进行离线算法*/
        for(int i = 1 ; i <= n ; i++){
           if(!indegree[i]){/*找到根节点，入度为0*/
             LCA(i);
             break;
           }
        }
        for(int i = 0 ; i < m ; i++)/*输出m次询问的答案*/
           printf("%d\n" , e[i].ans);
    }  
    return 0;
}