最近公共祖先LCA

另参考：http://www.blogjava.net/zellux/archive/2007/07/14/130241.aspx

LCA问题算法

　　1.离线算法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 {　　

if checked[v]=true　

　then 回答u和v的最近公共祖先为 ancestor[Find-Set(v)]　

　}　

}　　

由于是基于深度优先搜索的算法，只要调用LCA(root[T])就可以回答所有的提问了，这里root[T]表示树T的根，假设所有询问(u,v)构成集合P。　　2.在线算法 倍增法　　每次询问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 就是他们的最近公共祖先

编辑本段
实例算法

问题描述：　　设计一个算法，对于给定的树中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;
}