最近公共祖先LCA:Tarjan算法（介绍2）

对于有根树T的两个结点u、v，最近公共祖先LCA(T,u,v)表示一个结点x，满足x是u、v的祖先且x的深度尽可能大。

目录

1百科名片

2简介

3算法

▪  离线算法 Tarjan

▪  在线算法 倍增法

4算法实例

1百科名片编辑

最近公共祖先(Least Common Ancestors)

LCA

2简介编辑

另一种理解方式是把T理解为一个无向无环图，而LCA(T,u,v)即u到v的最短路上深度最小的点。

这里给出一个LCA的例子：

对于T=<V,E>

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

3算法编辑

离线算法 Tarjan

利用 并查集优越的时空复杂度，我们可以实现LCA问题的O(n+Q)算法，这里Q表示询问的次数。Tarjan算法基于 深度优先搜索的框架，对于新搜索到 的一个结点，首先创建由这个结点构成的集合，再对当前结点的每一个子树进行搜索，每搜索完一棵子树，则可确定子树内的LCA询问都已解决。其他的LCA询 问的结果必然在这个子树之外，这时把子树所形成的集合与当前结点的集合合并，并将当前结点设为这个集合的祖先。之后继续搜索下一棵子树，直到当前结点的所 有子树搜索完。这时把当前结点也设为已被检查过的，同时可以处理有关当前结点的LCA询问，如果有一个从当前结点到结点v的询问，且v已被检查过，则由于 进行的是 深度优先搜索，当前结点与v的最近公共祖先一定还没有被检查，而这个最近公共祖先的包涵v的子树一定已经搜索过了，那么这个最近公共祖先一定是v 所在集合的祖先。

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14

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] = true then回答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 就是他们的最近公共祖先

4算法实例编辑

问题描述：

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

编程任务：

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

数据输入：

由文件input.txt给出输入数据。第一行有1个正整数n，表示给定的树有n个顶点，编

号为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

#include<iostream>

#include<fstream>

using namespace std;

/********************快速排序****************************************/

inline void Swap(int &a, int &b)

{

int temp=a;

a=b;

b=temp;

}///:p

int Partition(int *a, int p, int r)

{

int i=p;

int j=r+1;

int x=a[p];

while(true)

{

while(a[++i]<x&&i<r);

while(a[--j]>x);

if(i>=j)

{

break;

}

Swap(a[i],a[j]);

}

a[p]=a[j];

a[j]=x;

return j;

}///:p

void QuickSort(int *a, int p, int r)

{

if(p<r)

{

int q=Partition(a,p,r);

QuickSort(a,p,q-1);

QuickSort(a,q+1,r);

}

}///:p

/*******************************************************************/

/***************二分法查找******************************************/

int FindSource(int *array, int source, int low, int high)

{

int mid;

while(low<=high)

{

mid=(low+high)/2;

if(source==array[mid])

{

return source;

}

else

{

if(source<array[mid])

{

high=mid-1;

}

else

{

low=mid+1;

}

}

}

return -1;

}///:p

/*******************************************************************/

class CommonTree

{

public:

CommonTree(int Max=10);

~CommonTree();

void getdata(int *treedata,int num);

int find_same_ancestor(int Node1, int Node2, int array_num);

void getroot(int i);

int Size();

void Print() const;

private:

int *TreeArray;

int size;

int root;

};///:p

CommonTree::CommonTree(int Max)

{

size=Max;

TreeArray=new int [size];

if(TreeArray==NULL)

{

exit(1);

}

}///:p

CommonTree::~CommonTree()

{

delete [] TreeArray;

}///:p

void CommonTree::getdata(int *treedata,int num)

{

int *p_temp=TreeArray;

TreeArray=treedata;

treedata=p_temp;

size=num;

delete [] treedata;

treedata=NULL;

}///:p

int CommonTree::find_same_ancestor(int Node1,int Node2, int array_num)

{

int *array_Node1=new int [array_num];

int *array_Node2=new int [array_num];

if(array_Node1==NULL&&array_Node2==NULL)

{

exit(1);

}

int x=Node1, array_Node1_num=0;

array_Node1[0]=x;

while(x!=root)

{

x=TreeArray[x];

array_Node1_num++;

array_Node1[array_Node1_num]=x;

}

x=Node2;

int array_Node2_num=0;

array_Node2[0]=x;

while(x!=root)

{

x=TreeArray[x];

array_Node2_num++;

array_Node2[array_Node2_num]=x;

}

QuickSort(array_Node2, 0, array_Node2_num);

int result=0;

for(int i=0; i<=array_Node1_num; i++)

{

result=FindSource(array_Node2, array_Node1[i], 0, array_Node2_num);

if(result!=-1)

{

break;

}

}

delete []array_Node1;

delete []array_Node2;

return result;

}///:p

inline int CommonTree::Size()

{

return size;

}///:p

inline void CommonTree::getroot(int i)

{

root=i;

}///:p

void CommonTree::Print() const

{

for(int i=1;i<size;i++)

{

cout<<this->TreeArray[i]<<" ";

}

cout<<endl;

cout<<root<<endl;

}///:p

int main()

{

ifstream in("input.txt");

if(in.fail())

{

cout<<"input error!"<<endl;

exit(1);

}

ofstream out("output.txt");

int NodeNum;

in>>NodeNum;

int *AncestorTree=new int [NodeNum+1];

if(AncestorTree==NULL)

{

exit(1);

}

memset(AncestorTree, 0, sizeof(int)*(NodeNum+1));

int father=1;

for(int j=0; j<NodeNum; j++)

{

int lop;

in>>lop;

for(int i=0;i<lop;i++)

{

int temp;

in>>temp;

AncestorTree[temp]=father;

}

father++;

}

for(j=1; j<=NodeNum;j++)

{

if(AncestorTree[j]==0)

{

AncestorTree[j]=j;

break;

}

}

int find_num;

in>>find_num;

int *result=new int [3*find_num];

if(result==NULL)

{

exit(1);

}

for(int i=0; i<2*find_num; i++)

{

in>>result[i];

}

CommonTree main_tree(10);

main_tree.getdata(AncestorTree,NodeNum+1);

main_tree.getroot(j);

int displace=0;

for(i=0; i<find_num; i++)

{

result[2*find_num+i]=main_tree.find_same_ancestor(result[displace], result[displace+1], NodeNum);

displace+=2;

}

displace=0;

for(i=0; i<find_num; i++)

{

out<<result[displace]<<" "<<result[displace+1]<<" "<<result[2*find_num+i];

displace+=2;

out<<endl;

}

delete [] result;

return 0;

}

c++代码实现

#include <iostream>

#include <stdio.h>

#include <memory.h>

using namespace std;

#define max_size 1010

int d[max_size], p[max_size][10];

int head[max_size];

int cnt;

//构造树时用到的机构体，看过一个大牛用的，感觉很好

struct Edge

{

int v;

int pre;

}eg[max_size];

//建树的函数

void add(int x, int y)

{

eg[cnt].v = y;

eg[cnt].pre = head[x];

head[x] = cnt++;

}

//dfs()初始整颗数，算出d[1-n], p[1-n][j];

void dfs(int k)

{

if (head[k] == 0)

{

return ;

}

int m, 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);

}

}

int find_lca(int x, int y)

{

int m, k;

if (x == y)return x;

if (d[x] < d[y])

{

m = x;

x = y;

y = m;

}

m = d[x] - d[y];

k = 0;

while (m)

//将x的深度调到和y的深度一样

{

if (m&1)

x = p[x][k];

m >>= 1;

k++;

}

if (x == y)return x;

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++;

}

else//如果p[x][k] = p[y][k],可以说明p[x][k]一定是x和y的共祖先，但不一定是最近的。

//所以向下找看还有没有更近的公共祖先

{

k--;

}

}

return x;

}

int main()

{

int i, 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 < m; i++)

{

scanf("%d%d", &x, &y);

printf("%d/n", find_lca(x, y));

}

}

return 0;

}