LCA <O(N), O(sqrt(N))>

参考资料：http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=lowestCommonAncestor#Another easy solution in O(N logN, O(logN)

算法思想：

1、求出每个节点i的父亲t[i]和在树中的深度l[i]

2、将树按sqrt(n)高度划分成sqrt(n)+0|1块，这样，属于同一大块的节点，p[i]相同。

3、假设求a到b，若a的pre不等于b的pre，说明a和b不属于一个大块，若l[a]>l[b]，就说明a所在的大块要在b所在大块的下面，则a = a->pre，跳到上面一个大块。l[b]<l[a]，同理。当a->pre == b->pre，则说明a和b已经属于同一个大块，所以两者深度相差不会超过sqrt(n)。然后就可以一层一层逼近公共祖先。

#include "stdio.h"
#include "string.h"
#include "math.h"

#define M 100
#define C 5

typedef struct _Node{
	int pos;
	int c;
	struct _Node* ch[C];
}Node, *pNode;

Node num[M];
/*          0  1  2   3  4  5   6  7  8   9 10  11 12*/
int a[M] = {3, 8, 2, 10, 4, 5, 11, 1, 6, 13, 9, 12, 7};
int p[M], l[M], t[M];  //分别表示，所属的大块（同一大块的p[i]相同），节点的深度，节点的父亲
int n=13, sec;

pNode init(){
	int i;
	memset(num, 0, sizeof(num));
	for(i=0; i<n; i++)
		num[i].pos = i;

	sec = (int)sqrt(n);

	num[7].c = 3;
	num[7].ch[0] = &num[2];
	num[7].ch[1] = &num[0];
	num[7].ch[2] = &num[4];
	
	num[0].c = 3;
	num[0].ch[0] = &num[5];
	num[0].ch[1] = &num[8];
	num[0].ch[2] = &num[12];

	num[8].c = 2;
	num[8].ch[0] = &num[1];
	num[8].ch[1] = &num[10];

	num[12].c = 2;
	num[12].ch[0] = &num[3];
	num[12].ch[1] = &num[6];

	num[3].c = 2;
	num[3].ch[0] = &num[11];
	num[3].ch[1] = &num[9];

	return &num[7];
}

void DFS(pNode pare, pNode r, int dep, pNode pre){
	int i;
	if(pare) 
		t[r->pos] = pare->pos;
	else
		t[r->pos] = -1;
	if(pre)
		p[r->pos] = pre->pos;
	else
		p[r->pos] = -1;
	l[r->pos] = dep;
	if(dep%sec==0) pre = r;

	for(i=0; i<r->c; i++){
		DFS(r, r->ch[i], dep+1, pre);
	}
}

int LCA(int s, int e){
	while(p[s]!=p[e]){
		if(l[s]>l[e])
			s = p[s];
		else
			e = p[e];
	}

	while(s!=e){
		if(l[s]>l[e])
			s = t[s];
		else
			e = t[e];
	}
	return s;
}

void main(){
	int i, j;
	pNode root;
	root = init();
	DFS(0, root, 1, 0);
	for(i=0; i<n; i++){
		for(j=i+1; j<n; j++)
			printf("%d-%d:%d ", a[i], a[j], a[LCA(i, j)]);
		printf("\n");
	}
}

结合上一篇的《RMQ转LCA》就能在O(sqrt(n))的时间复杂度查询公共祖先，即区间最值