最近公共祖先

算法简介

这里给出一个LCA的例子：

对于T=

V={1,2,3,4,5}

E={(1,2),(1,3),(3,4),(3,5)}

则有：

LCA(T,5,2)=1

LCA(T,3,4)=3

LCA(T,4,5)=3

算法

离线算法 Tarjan

利用并查集优越的时空複杂度，我们可以实现LCA问题的O(n+Q)算法，这里Q表示询问的次数。

Tarjan算法基于深度优先搜寻的框架，对于新搜寻到 的一个结点，首先创建由这个结点构成的集合，再对当前结点的每一个子树进行搜寻，每搜寻完一棵子树，则可确定子树内的LCA询问都已解决。其他的LCA询问的结果必然在这个子树之外，这时把子树所形成的集合与当前结点的集合合併，并将当前结点设为这个集合的祖先。

之后继续搜寻下一棵子树，直到当前结点的所 有子树搜寻完。这时把当前结点也设为已被检查过的，同时可以处理有关当前结点的LCA询问，如果有一个从当前结点到结点v的询问，且v已被检查过，则由于 进行的是深度优先搜寻，当前结点与v的最近公共祖先一定还没有被检查，而这个最近公共祖先的包涵v的子树一定已经搜寻过了，那么这个最近公共祖先一定是v 所在集合的祖先。

下面给出这个算法的伪代码描述：

LCA(u){Make-Set(u)ancestor[Find-Set(u)]=u对于u的每一个孩子v{LCA(v)Union(u)ancestor[Find-Set(u)]=u}checked[u]=true对于每个(u,v)属于P{ifchecked[v]=truethen回答u和v的最近公共祖先为ancestor[Find-Set(v)]}}

由于是基于深度优先搜寻的算法，只要调用LCA(root[T])就可以回答所有的提问了，这里root[T]表示树T的根，假设所有询问(u,v)构成集合P。

线上算法 倍增法

每次询问O(logN)

d[i] 表示 i节点的深度， p[i,,j] 表示 i 的 2^j 倍祖先

那么就有一个递推式子 p[i,,j]=p[p[i,,j-1],,j-1]

这样子一个O(NlogN)的预处理求出每个节点的 2^k 的祖先

然后对于每一个询问的点对(a, b)的最近公共祖先就是：

先判断是否 d[a] > d[b] ,如果是的话就交换一下(保证 a 的深度小于 b 方便下面的操作)，然后把b 调到与a 同深度, 同深度以后再把a, b 同时往上调(dec(j)) 调到有一个最小的j 满足p[a,,j]!=p[b,,j] (a b 是在不断更新的), 最后再把 a, b 往上调 (a=p[a,0], b=p[b,0]) 一个一个向上调直到a = b, 这时 a or b 就是他们的最近公共祖先。

算法实例

设计一个算法，对于给定的树中 结点返回它们的最近公共祖先。

编程任务：

对于给定的树和树中结点对，计算结点对的最近公共祖先。

数据输入：

由档案input.txt给出输入数据。

第一行有1个正整数n，表示给定的树有n个顶点，编0号为1，2，…，n。编号为1 的顶点是树根。接下来的n 行中，第i+1 行描述与i 个顶点相关联的子结点的信息。每行的第一个正整数k表示该顶点的儿子结点数。其后k个数中，每1 个数表示1 个儿子结点的编号。当k=0 时表示相应的结点是叶结点。档案的第n+2 行是1 个正整数m，表示要计算最近公共祖先的m个结点对。接下来的m行，每行2 个正整数，是要计算最近公共祖先的结点编号。

结果输出:

将编程计算出的m个结点对的最近公共祖先结点编号输出到档案output.txt。每行3 个

正整数，前2 个是结点对编号，第3 个是它们的最近公共祖先结点编号。

输入档案示例(input.txt)

12

3 2 3 4

2 5 6

0

0

2 7 8

2 9 10

0

0

0

2 11 12

0

0

5

3 11

7 12

4 8

9 12

8 10

输出档案示例(output.txt)

3 11 1

7 12 2

4 8 1

9 12 6

8 10 2

C代码实现：#include#includeusingnamespacestd;inlinevoidSwap(int&a,int&b){inttemp=a;a=b;b=temp;}intPartition(int*a,intp,intr){inti=p;intj=r+1;intx=a[p];while(true){while(a[++i]x);if(i>=j)break;Swap(a[i],a[j]);}a[p]=a[j];a[j]=x;returnj;}voidQuickSort(int*a,intp,intr){if(pTreeArray[i]<<;cout<>NodeNum;int*AncestorTree=newint[NodeNum+1];if(AncestorTree==NULL)exit(1);memset(AncestorTree,0,sizeof(int)*(NodeNum+1));intfather=1;for(intj=0;j>lop;for(inti=0;i>temp;AncestorTree[temp]=father;}father++;}for(j=1;j<=NodeNum;j++){if(AncestorTree[j]==0){AncestorTree[j]=j;break;}}intfind_num;in>>find_num;int*result=newint[3*find_num];if(result==NULL)exit(1);for(inti=0;i<2*find_num;i++)in>>result[i];CommonTreemain_tree(10);main_tree.getdata(AncestorTree,NodeNum+1);main_tree.getroot(j);intdisplace=0;for(i=0;i
 
C++代码实现：#include#include#includeusingnamespacestd;#definemax_size1010intd[max_size],p[max_size][10];inthead[max_size];intcnt;structEdge{intv;intpre;}eg[max_size];//建树的函式voidadd(intx,inty){eg[cnt].v=y;eg[cnt].pre=head[x];head[x]=cnt++;}//dfs()初始整颗数，算出d[1-n],p[1-n][j];voiddfs(intk){if(head[k]==0)return;intm,x,i,j;for(i=head[k];i!=0;i=eg[i].pre){x=eg[i].v;p[x][0]=k;m=k;d[x]=d[k]+1;for(j=0;p[m][j]!=0;j++){p[x][j+1]=p[m][j];//利用公式p[x][j]=p[p[x][j-1]][j-1],这里的m就是p[x][j-1];m=p[m][j];}dfs(x);}}intfind_lca(intx,inty){intm,k;if(x==y)returnx;if(d[x]>=1;k++;}if(x==y)returnx;k=0;//向上调节，找最近公共祖先，算法的核心，相当于一个二分查找。while(x!=y){if(p[x][k]!=p[y][k]||p[x][k]==p[y][k]&&k==0){//如果p[x][k]还不相等，说明节点p[x][k]还在所求点的下面，所以继续向上调节;如果相等了，并且就是他们父节点，则那个节点一定就是所求点。x=p[x][k];y=p[y][k];k++;}elsek--;//如果p[x][k]=p[y][k],可以说明p[x][k]一定是x和y的共祖先，但不一定是最近的,所以向下找看还有没有更近的公共祖先}returnx;}intmain(){inti,n,m,x,y;while(cin>>n>>m){memset(head,0,sizeof(head));memset(p,0,sizeof(p));memset(d,0,sizeof(d));cnt=1;for(i=2;i<=n;i++){scanf(%d,&x);add(x,i);}dfs(1);for(i=0;i