poj1330 Nearest Common Ancestors（）

本文代码参考kuangbin：点击打开链接

本文解释参考：点击打开链接

题目链接:点击打开链接

题目大意：给出n 个结点和n-1条边构成一个生成树

然后查询第i和第j个节点的第一个公共结点

思路：LCA的裸题

对于该问题，最容易想到的算法是分别从节点u和v回溯到根节点，获取u和v到根节点的路径P1，P2，其中P1和P2可以看成两条单链表，这就转换成常见的一道面试题：【判断两个单链表是否相交，如果相交，给出相交的第一个点。】。该算法总的复杂度是O（n）（其中n是树节点个数）。

本题介绍了两种比较高效的算法解决这个问题，其中一个是在线算法（DFS+ST），另一个是离线算法（Tarjan算法）

离线算法（Tarjan算法）描述：

所谓离线算法，是指首先读入所有的询问（求一次LCA叫做一次询问），然后重新组织查询处理顺序以便得到更高效的处理方法。Tarjan算法是一个常见的用于解决LCA问题的离线算法，它结合了深度优先遍历和并查集，整个算法为线性处理时间。

Tarjan算法是基于并查集的，利用并查集优越的时空复杂度，可以实现LCA问题的O(n+Q)算法，这里Q表示询问 的次数。更多关于并查集的资料，可阅读这篇文章：《数据结构之并查集》。

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

详细离线算法博客参照，有图文：点击打开链接

/*POJ 1330离线算法*/#include<stdio.h>#include<string.h>#include<iostream>#include<algorithm>#include<math.h>#include<vector>using namespace std;const int MAXN=10010;int F[MAXN];//并查集int r[MAXN];//并查集中集合的个数bool vis[MAXN];//访问标记int ancestor[MAXN];//祖先struct Node{    int to,next;}edge[MAXN*2];int head[MAXN];int tol;void addedge(int a,int b){    edge[tol].to=b;    edge[tol].next=head[a];    head[a]=tol++;    edge[tol].to=a;    edge[tol].next=head[b];    head[b]=tol++;}struct Query{    int q,next;    int index;//查询编号}query[MAXN*2];//查询数int answer[MAXN*2];//查询结果int cnt;int h[MAXN];int tt;int Q;//查询个数void add_query(int a,int b,int i){    query[tt].q=b;    query[tt].next=h[a];    query[tt].index=i;    h[a]=tt++;    query[tt].q=a;    query[tt].next=h[b];    query[tt].index=i;    h[b]=tt++;}void init(int n)//初始化{    for(int i=1;i<=n;i++)    {        F[i]=-1;        r[i]=1;        vis[i]=false;        ancestor[i]=0;        tol=0;        tt=0;        cnt=0;//已经查询到的个数    }    memset(head,-1,sizeof(head));    memset(h,-1,sizeof(h));}int find(int x){    if(F[x]==-1)return x;    return F[x]=find(F[x]);}void Union(int x,int y)//合并{    int t1=find(x);    int t2=find(y);    if(t1!=t2)    {        if(r[t1]<=r[t2])//y所在集合数量多的话  将x的祖先指向y并查集 同时将数量也增加过去        {            F[t1]=t2;            r[t2]+=r[t1];        }        else        {            F[t2]=t1;            r[t1]+=r[t2];        }    }}void LCA(int u){    //if(cnt>=Q)return;//不要加这个    ancestor[u]=u;    vis[u]=true;//这个一定要放在前面    for(int i=head[u];i!=-1;i=edge[i].next)    {        int v=edge[i].to;        if(vis[v])continue;        LCA(v);        Union(u,v);        ancestor[find(u)]=u;    }    for(int i=h[u];i!=-1;i=query[i].next)    {        int v=query[i].q;        if(vis[v])//判断他要查询的结点是否已经被访问过        {            answer[query[i].index]=ancestor[find(v)];            cnt++;//已经找到的答案数        }    }}bool flag[MAXN];//用于找到根节点int main(){    //freopen("in.txt","r",stdin);    //freopen("out.txt","w",stdout);    int T;    int N;    int u,v;    scanf("%d",&T);    while(T--)    {        scanf("%d",&N);        init(N);        memset(flag,false,sizeof(flag));        for(int i=1;i<N;i++)        {            scanf("%d%d",&u,&v);            flag[v]=true;            addedge(u,v);//邻接表存储        }        Q=1;//查询只有一组        scanf("%d%d",&u,&v);        add_query(u,v,0);//增加一组查询  也同样用邻接表存储        int root;        for(int i=1;i<=N;i++)          if(!flag[i])          {              root=i;//查找根节点 即入度为0的点              break;          }        LCA(root);        for(int i=0;i<Q;i++)//输出所有答案          printf("%d\n",answer[i]);    }    return 0;}

在线算法DFS+ST描述(思想是：将树看成一个无向图，u和v的公共祖先一定在u与v之间的最短路径上)：

（1）DFS：从树T的根开始，进行深度优先遍历（将树T看成一个无向图），并记录下每次到达的顶点。第一个的结点是root(T)，每经过一条边都记录它的端点。由于每条边恰好经过2次，因此一共记录了2n-1个结点，用E[1, ... , 2n-1]来表示。

（2）计算R：用R[i]表示E数组中第一个值为i的元素下标，即如果R[u] < R[v]时，DFS访问的顺序是E[R[u], R[u]+1, …, R[v]]。虽然其中包含u的后代，但深度最小的还是u与v的公共祖先。

（3）RMQ：当R[u] ≥ R[v]时，LCA[T, u, v] = RMQ(L, R[v], R[u])；否则LCA[T, u, v] = RMQ(L, R[u], R[v])，计算RMQ。

由于RMQ中使用的ST算法是在线算法，所以这个算法也是在线算法。

【举例说明】

T=<V,E>，其中V={A,B,C,D,E,F,G},E={AB,AC,BD,BE,EF,EG},且A为树根。则图T的DFS结果为：A->B->D->B->E->F->E->G->E->B->A->C->A，要求D和G的最近公共祖先, 则LCA[T, D, G] = RMQ(L, R[D], R[G])= RMQ(L, 3, 8)，L中第4到7个元素的深度分别为：1,2,3,3，则深度最小的是B。

/*POJ 1330求最近公共祖先（LCA）在线算法 DFS+ST描述对于本题只有一个查询，不适合用在线算法，用离线算法效率更高*/#include<stdio.h>#include<iostream>#include<math.h>#include<string.h>#include<algorithm>using namespace std;const int MAXN=10010;int rmq[2*MAXN];//建立RMQ的数组//***************************//ST算法，里面含有初始化init(n)和query(s,t)函数//点的编号从1开始，1-n.返回最小值的下标//***************************struct ST{    int mm[2*MAXN];//mm[i]表示i的最高位，mm[1]=0,mm[2]=1,mm[3]=1,mm[4]=2    int dp[MAXN*2][20];    void init(int n)    {        mm[0]=-1;        for(int i=1;i<=n;i++)        {            mm[i]=((i&(i-1))==0?mm[i-1]+1:mm[i-1]);            dp[i][0]=i;        }        for(int j=1;j<=mm[n];j++)          for(int i=1;i+(1<<j)-1<=n;i++)             dp[i][j]=rmq[dp[i][j-1]]<rmq[dp[i+(1<<(j-1))][j-1]]?dp[i][j-1]:dp[i+(1<<(j-1))][j-1];    }    int query(int a,int b)//查询a到b间最小值的下标    {        if(a>b)swap(a,b);        int k=mm[b-a+1];        return rmq[dp[a][k]]<rmq[dp[b-(1<<k)+1][k]]?dp[a][k]:dp[b-(1<<k)+1][k];    }};//边的结构体定义struct Node{    int to,next;};/* ******************************************LCA转化为RMQ的问题MAXN为最大结点数。ST的数组 和 F，edge要设置为2*MAXNF是欧拉序列，rmq是深度序列，P是某点在F中第一次出现的下标*********************************************/struct LCA2RMQ{    int n;//结点个数    Node edge[2*MAXN];//树的边,因为是建无向边，所以是两倍    int tol;//边的计数    int head[MAXN];//头结点    bool vis[MAXN];//访问标记    int F[2*MAXN];//F是欧拉序列，就是DFS遍历的顺序    int P[MAXN];//某点在F中第一次出现的位置    int cnt;    ST st;    void init(int n)//n为所以点的总个数，可以从0开始，也可以从1开始    {        this->n=n;        tol=0;        memset(head,-1,sizeof(head));    }    void addedge(int a,int b)//加边    {        edge[tol].to=b;        edge[tol].next=head[a];        head[a]=tol++;        edge[tol].to=a;        edge[tol].next=head[b];        head[b]=tol++;    }    int query(int a,int b)//传入两个节点，返回他们的LCA编号    {        return F[st.query(P[a],P[b])];    }    void dfs(int a,int lev)    {        vis[a]=true;        ++cnt;//先加，保证F序列和rmq序列从1开始        F[cnt]=a;//欧拉序列，编号从1开始，共2*n-1个元素        rmq[cnt]=lev;//rmq数组是深度序列        P[a]=cnt;        for(int i=head[a];i!=-1;i=edge[i].next)        {            int v=edge[i].to;            if(vis[v])continue;            dfs(v,lev+1);            ++cnt;            F[cnt]=a;            rmq[cnt]=lev;        }    }    void solve(int root)    {        memset(vis,false,sizeof(vis));        cnt=0;        dfs(root,0);        st.init(2*n-1);    }}lca;bool flag[MAXN];int main(){    int T;    int N;    int u,v;    scanf("%d",&T);    while(T--)    {        scanf("%d",&N);        memset(flag,false,sizeof(flag));        lca.init(N);        for(int i=1;i<N;i++)        {            scanf("%d%d",&u,&v);            lca.addedge(u,v);            flag[v]=true;        }        int root;        for(int i=1;i<=N;i++)          if(!flag[i])          {              root=i;              break;          }        lca.solve(root);        scanf("%d%d",&u,&v);        printf("%d\n",lca.query(u,v));    }    return 0;}