LCA 离线算法： tarjan
贴一个大牛的见解，写的很好，深入浅出：
http://blog.csdn.net/geniusluzh/article/details/6609685
对于最近公共祖先问题，我们先来看这样一个性质，当两个节点（u，v）的最近公共祖先是x时，那么我们可以确定的说，当进行后序遍历的时候，必然先访问完x的所有子树，然后才会返回到x所在的节点。这个性质就是我们使用Tarjan算法解决最近公共祖先问题的核心思想。
同时我们会想这个怎么能够保证是最近的公共祖先呢？我们这样看，因为我们是逐渐向上回溯的，所以我们每次访问完某个节点x的一棵子树，我们就将该子树所有节点放进该节点x所在的集合，并且我们设置这个集合所有元素的祖先是该节点x。那么我们有理由相信, 任何一个不属于已经访问的节点和已经访问的节点的LCA一定是当前这个根节点. 于是我们每次访问完一棵子树, 只需要将子树放进根节点对应的集合即可.
我们简单举例来说明这一点。假设我们刚刚已经完成访问的节点是a，那么我们看与其一同被询问的另外一个点b是否已经被访问过了，若已经被访问过了，那么这个时候最近公共祖先必然是b所在集合对应的祖先c，因为我们对a的访问就是从最近公共祖先c转过来的，并且在从c的子树b转向a的时候，我们已经将b的祖先置为了c，同时这个c也是a的祖先，那么c必然是a、b的最近公共祖先。
说一下自己的理解：
所谓的lca 离线算法：
1. 把所有的询问都存起来，用链式前向星存储会很快。 ？虽然我还没搞懂为什么链式前向星会加快很多效率
2. 把树建好，也可以用力链式前向星，配合递归 完成后序遍历。
3. 建立并查集，并开始dfs，完成后序遍历，对一个节点，扫描他的所有子树，扫完之后会一步一步回溯，将每个节点的祖先更新，同时如果有询问这个节点的query，对这一次询问做出判断（如果另外一个询问中的另外一个节点v我们已经扫描过了，那个可以得出结果：v父亲节点的祖先。 如果没有扫到过，那么我们就只能等扫描到v 的时候再来解答这一个询问。）
这就是整个 拯救世界的tarjan 算法递归的过程。。。 如果有理解的不正确的地方， 欢(那)迎(你)大(来)家(打)指(我)正(啊)。
PS：模板是kuangbin大牛的，自己加了一些理解。
/* Author :kuangbin /* * POJ 1470 * 给出一颗有向树，Q个查询 * 输出查询结果中每个点出现次数 */
/* * LCA离线算法，Tarjan * 复杂度O(n+Q); */
*/
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
const int MAXN = 1010;
const int MAXQ = 500010;//查询数的最大值
//并查集部分
int F[MAXN]; //初始化为-1
int find(int x)
{
if(F[x] == -1)return x;
return F[x] = find(F[x]);
}
void bing(int u,int v)
{
int t1 = find(u);
int t2 = find(v);
if(t1 != t2)
F[t1] = t2;
}
//************************
bool vis[MAXN];//访问标记
int ancestor[MAXN];//祖先
struct Edge
{
int to,next;
}edge[MAXN*2];
int head[MAXN],tot;
void addedge(int u,int v)
{
edge[tot].to = v;
edge[tot].next = head[u];
head[u] = tot++;
}
struct Query
{
int q,next;
int index; //查询编号
}query[MAXQ*2];
int answer[MAXQ];//存储最后的查询结果，下标0~Q-1
int h[MAXQ]; //？ h
int tt;
int Q;
void add_query(int u,int v,int index) //用链式结构 所有的询问都存储起来
{
query[tt].q = v;
query[tt].next = h[u]; //？ h
query[tt].index = index;
h[u] = tt++;
query[tt].q = u;
query[tt].next = h[v];
query[tt].index = index;
h[v] = tt++;
}
void init()
{
tot = 0;
memset(head,-1,sizeof(head));
tt = 0;
memset(h,-1,sizeof(h));
memset(vis,false,sizeof(vis));
memset(F,-1,sizeof(F));
memset(ancestor,0,sizeof(ancestor));
}
void LCA(int u) // 注意 这是一个后序遍历
{
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; //如果 v已经有了祖先，那么跳过
LCA(v); //注意递归
bing(u,v); //将 u-v放在一个并查集里面F[u]=v
ancestor[find(u)] = u; //find: F[u] 的祖先为u 即:u和u的子树所有节点祖先=u
}
for(int i = h[u];i != -1;i = query[i].next) // h[u]即u上一条边的tt，
{
int v = query[i].q;
if(vis[v]) //如果v已经访问过，那么lca=v的祖先
{
answer[query[i].index] = ancestor[find(v)];
}
}
}
bool flag[MAXN];
int Count_num[MAXN];
int main()
{
//freopen("1.txt","r",stdin);
int n;
int u,v,k;
while(scanf("%d",&n) == 1)
{
init();
memset(flag,false,sizeof(flag));
for(int i = 1;i <= n;i++)
{
scanf("%d:(%d)",&u,&k);
while(k--)
{
scanf("%d",&v);
flag[v] = true;
addedge(u,v);
addedge(v,u);
}
}
scanf("%d",&Q);
for(int i = 0;i < Q;i++)
{
char ch;
cin>>ch;
scanf("%d %d)",&u,&v);
add_query(u,v,i);
}
int root;
for(int i = 1;i <= n;i++)
if(!flag[i])
{
root = i;
break;
}
LCA(root);
memset(Count_num,0,sizeof(Count_num));
for(int i = 0;i < Q;i++)
Count_num[answer[i]]++;
for(int i = 1;i <= n;i++)
if(Count_num[i] > 0)
printf("%d:%d\n",i,Count_num[i]);
}
return 0;
}
如果看不懂 存储询问中的链式结构，有蒟蒻 手动绘图一张：
实际上h[i]存储的就是 i的上一条边
