POJ 1330 Nearest Common Ancestors 最近公共祖先模板/在线/离线

题意：求树上两个节点的最近公共祖先

算法一：tarjan

LCA(u) {
　　Make-Set(u)
　　ancestor[Find-Set(u)]=u  //设置u所在集合的祖先
　　对于u的每一个孩子v {
　　 LCA(v)
　　 Union(v,u)              //把v生成的子集并入u中
　　 ancestor[Find-Set(u)]=u //防止采用树形启发式合并使u的集合根(代表)变化
　　}
　　checked[u]=true
　　对于每个(u,v)属于P {
　　 if checked[v]=true
　　 then 回答u和v的最近公共祖先为 ancestor[Find-Set(v)]
　　}
}

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;

/*
时间复杂度O(N+Q)
离线算法，必须先记录询问
对于每一对询问lac(u,v)，在u,v的查询队列里各加一次
*/


const int MAXN = 10010;

class LCA_Tarjan
{
public:
    int n, father[MAXN];
    bool vis[MAXN];
    vector<int> edge[MAXN];
    vector<int> query[MAXN];

    void init(int n)
    {
        for(int i = 1; i <= n; i++)
        {
            vis[i] = false;
            edge[i].clear();
            query[i].clear();
        }
        make_set(n);
    }

    void make_set(int n) //下标从1开始
    {
        for(int i = 1; i <= n; i++)
            father[i] = i;
    }

    int find(int u)
    {
        if(u == father[u])
            return u;
        return father[u] = find(father[u]);
    }

    void Union(int u, int v) //可以优化
    {
        int fu = find(u);
        int fv = find(v);
        if(fv != fu)
            father[fv] = fu;
    }

    void tarjan(int u)
    {
        father[u] = u;
        int sz = edge[u].size();
        for(int i = 0; i < sz; i++)
        {
            tarjan(edge[u][i]);
            Union(u, edge[u][i]);
            father[find(u)] = u;
        }

        vis[u] = true;
        sz = query[u].size();
        for(int i = 0; i < sz; i++)
        {
            if(vis[query[u][i]] == true)
                cout << father[find(query[u][i])] << endl;
        }
    }
};

int main()
{
    LCA_Tarjan t;
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d", &t.n);
        t.init(t.n);

        int u, v;
        bool notRoot[MAXN] = {0};
        for(int i = 1; i < t.n; i++)
        {
            scanf("%d %d", &u, &v);
            t.edge[u].push_back(v);
            notRoot[v] = true;
        }

        scanf("%d %d", &u, &v);
        t.query[u].push_back(v);
        t.query[v].push_back(u);
        for(int i = 1; i <= t.n; i++)
            if(notRoot[i] == false) {t.tarjan(i); break;}
    }
    return 0;
}

算法二LCA向RMQ的转化：

对有根树T进行DFS，将遍历到的结点按照顺序记下，我们将得到一个长度为2N – 1的序列，称之为T的欧拉序列F

每个结点都在欧拉序列中出现，我们记录结点u在欧拉序列中第一次出现的位置为pos(u)

根据DFS的性质，对于两结点u、v，从pos(u)遍历到pos(v)的过程中经过LCA(u, v)有且仅有一次，且深度是深度序列B[pos(u)…pos(v)]中最小的

即LCA(T, u, v) = RMQ(B, pos(u), pos(v))，并且问题规模仍然是O(N)的

这就证明了LCA问题可以转化成RMQ问题

LCA与RMQ问题可以互相转化，并且可以在O(N)的时间内完成！

/*
1.时间复杂度O(N*logN+Q)
2.在线算法
3.搜索之后n个节点得到2*n-1个编号
*/

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
using namespace std;

const int MAXN = 10010;
const int PP = 25;

class LCA_RMQ
{
public:
    int n;
    int pow2[PP]; //2^k
    int tim; //时间戳,从1开始
    int first[MAXN]; //节点第一次访问的时间戳
    int nodeId[MAXN*2]; //与相应时间戳对应的节点编号
    int dep[MAXN*2]; //深度
    int dp[MAXN*2][PP]; //搜索之后得到2*n-1个编号
    bool vis[MAXN]; //记录节点是否被访问过
    vector<int> edge[MAXN];

    void init(int n)
    {
        for(int i = 0; i < PP; i++)
            pow2[i] = (1<<i);

        for(int i = 1; i <= n; i++)
        {
            edge[i].clear();
            vis[i] = false;
        }

    }

    void addedge(int u ,int v)
    {
        edge[u].push_back(v);
    }

    void dfs(int u ,int d) //u是节点, d是深度
    {
        tim++;  //时间戳+1
        vis[u] = true;
        nodeId[tim] = u;   //记录与时间戳相对应的节点
        first[u] = tim; //记录下节点u首次访问的时间戳
        dep[tim] = d;  //根节点的深度为1
        int sz = edge[u].size();
        for(int i = 0; i < sz; i++)
        {
            int v = edge[u][i];
            if(vis[v] == false)
            {
                dfs(v, d + 1);
                tim++;
                nodeId[tim] = u;  //只要访问的不是叶子节点，tim都要重复增加
                dep[tim] = d;
            }
        }
    }

    void ST(int len)
    {
        int k = (int)(log(len+1.0) / log(2.0));

        for(int i = 1; i <= len; i++)
            dp[i][0] = i;

        for(int j = 1; j <= k; j++)
            for(int i = 1; i + pow2[j] - 1 <= len; i++)
            {
                int a = dp[i][j-1]; //a, b均为下标
                int b = dp[i+pow2[j-1]][j-1];
                if(dep[a] < dep[b]) dp[i][j] = a;
                else dp[i][j] = b;
            }
    }

    int RMQ(int x ,int y)
    {
        int k = (int)(log(y-x+1.0) / log(2.0));
        int a = dp[x][k];
        int b = dp[y-pow2[k]+1][k];
        if(dep[a] < dep[b]) return a;
        else return b;
    }

    int LCA(int u ,int v)
    {
        int x = first[u];
        int y = first[v];
        if(x > y) swap(x,y);
        int index = RMQ(x,y);
        return nodeId[index];
    }
};

LCA_RMQ t;

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int u, v, rt;
        bool notRoot[MAXN] = {0};
        scanf("%d",&t.n);
        t.init(t.n);
        for(int i = 1; i < t.n; i++)
        {
            scanf("%d %d",&u,&v);
            t.addedge(u, v);
            notRoot[v] = true;
        }
        scanf("%d %d", &u, &v);

        for(int i = 1; i <= t.n; i++)
            if(notRoot[i] == false) {rt = i; break;}

        t.tim = 0;
        t.dfs(rt, 1); //根节点深度为1
        t.ST(2 * t.n - 1);
        int ans = t.LCA(u, v);
        printf("%d\n", ans);
    }
    return 0;
}