LCA（最近公共祖先）——离线 Tarjan 算法

tarjan算法的步骤是(当dfs到节点u时):
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所在的集合的祖先

不懂请点击

伪代码：

Tarjan(u)//marge和find为并查集合并函数和查找函数
{
    for each(u,v)    //访问所有u子节点v
    {
        Tarjan(v);        //继续往下遍历
        marge(u,v);    //合并v到u上
        标记v被访问过;
    }
    for each(u,e)    //访问所有和u有询问关系的e
    {
        如果e被访问过;
        u,e的最近公共祖先为find(e);
    }
}

模板：

 #include<iostream>
 #include<cstdio>
 #include<vector>
 #include<algorithm>
 using namespace std;
 const int maxn = ;

 int rank[maxn];            //并查集结点高度
 int pre[maxn];            //并查集父节点
 int anc[maxn];            //祖先
 int indgree[maxn];        //保存每个节点的入度
 bool vis[maxn];
 vector<int> tree[maxn];    //保存树
 vector<int> qes[maxn];    //保存查询
 int vertex_num;            //顶点数 

 void init()
 {
     memset(rank,,sizeof(rank));
     memset(vis,,sizeof(vis));
     memset(indgree,,sizeof(indgree));
     memset(anc,,sizeof(anc));
     for(int i=;i<=vertex_num;i++){
         pre[i] = i;
         tree[i].clear();
         qes[i].clear();
     }
 }

 int find_pre(int x)        //查找函数
 {
     if(pre[x] == x){
         return x;
     }
     else{
         pre[x] = find_pre(pre[x]);        //压缩路径
     }
     return pre[x];
 }

 void Union(int x,int y)
 {
     x = find_pre(x);
     y = find_pre(y);
     if(x == y){
         return ;
     }
     else{
         if(rank[x] > rank[y]){
             pre[y] = x;
         }
         else if(rank[x] == rank[y]){        //x和y深度相同时， y向x合并
             rank[x]++;
             pre[y] = x;
         }
         else{
             pre[x] = y;
         }
     }
 }

 int lca(int u)
 {
     anc[u] = u;
     for(int i=;i<tree[u].size();i++){
         lca(tree[u][i]);
         Union(u,tree[u][i]);
         anc[find_pre(u)]=u;
     }
     vis[u] = ;
     for(int i=;i<qes[u].size();i++){
         if(vis[qes[u][i]] == ){
             return anc[find_pre(qes[u][i])];
         }
     }
 }

 int main()
 {
     cout<<"请输入顶点数：";
     cin>>vertex_num;
     init();
     int u,v,ans;
     cout<<"请依次输入各边：\n";
     for(int i=;i<vertex_num;i++){
         cin>>u>>v;
         tree[u].push_back(v);
         indgree[v]++;
     }
     cout<<"请输入要查询的两个数：";
     cin>>u>>v;
     qes[u].push_back(v);
     qes[v].push_back(u);
     for(int i=;i<=vertex_num;i++){
         if(indgree[i] == ){
             ans = lca(i);
             printf("(%d,%d)的LCA是：%d\n",u,v,ans);
             break;
         }
     }
     return ;
 }

上一个图，来测试模板：

题目：POJ 1470

代码：点击

/*
 * POJ 1470
 * 给出一颗有向树，Q个查询
 * 输出查询结果中每个点出现次数
 */
/*
 * LCA离线算法，Tarjan
 * 复杂度O(n+Q);
 */