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的上一条边