hdu 2586 最近公共祖先 LCA

最近公共祖先问题~~

题目大意：一个村子里有n个房子，这n个房子用n-1条路连接起来，接下了有m次询问，每次询问两个房子a,b之间的距离是多少。

很明显的最近公共祖先问题，先建一棵树，然后求出每一点i到树根的距离dis[i],然后每次询问a，b之间的距离=dis[a]+dis[b]-2*dis[LCA(a,b)];

LCA(a,b)即是a，b的最近公共祖先。。

对于一棵有根树，就会有父亲结点，祖先结点，当然最近公共祖先就是这两个点所有的祖先结点中深度最大的一个结点。

       0

       |

       1

     /   \

   2      3

比如说在这里，如果0为根的话，那么1是2和3的父亲结点，0是1的父亲结点，0和1都是2和3的公共祖先结点，但是1才是最近的公共祖先结点，或者说1是2和3的所有祖先结点中距离根结点最远的祖先结点。

在求解最近公共祖先为问题上，用到的是Tarjan的思想，从根结点开始形成一棵深搜树，非常好的处理技巧就是在回溯到结点u的时候，u的子树已经遍历，这时候才把u结点放入合并集合中，这样u结点和所有u的子树中的结点的最近公共祖先就是u了，u和还未遍历的所有u的兄弟结点及子树中的最近公共祖先就是u的父亲结点。以此类推。。这样我们在对树深度遍历的时候就很自然的将树中的结点分成若干的集合，两个集合中的所属不同集合的任意一对顶点的公共祖先都是相同的，也就是说这两个集合的最近公共最先只有一个。对于每个集合而言可以用并查集来优化，时间复杂度就大大降低了，为O(n + q)，n为总结点数，q为询问结点对数。

另外Tarjan解法，是一个离线算法，就是说它必须将所有询问先记录下来，再一次性的求出每个点对的最近公共祖先，只有这样才可以达到降低时间复杂度

//parent为并查集，FIND为并查集的查找操作
//QUERY为询问结点对集合
//TREE为基图有根树
 Tarjan(u)
      visit[u] = true
      for each (u, v) in QUERY
          if visit[v]
              ans(u, v) = FIND(v)
      for each (u, v) in TREE    
          if !visit[v]
              Tarjan(v)
              parent[v] = u

题目代码：

<span style="font-size:14px;"># include<stdio.h>
# include<string.h>
# define N 40005
# define M 205
struct node{
    int from,to,next,val;
}edge[2*N];
struct node1{
    int from,to,next,num;
}edge1[2*M];
int tol,head[N],head1[N],tol1,father[N],dis[N],LCA[M],n,m;
bool visit[N];
void add(int a,int b,int c)
{
    edge[tol].from=a;edge[tol].to=b;edge[tol].next=head[a];edge[tol].val=c;head[a]=tol++;
}
void add1(int a,int b,int c)
{
    edge1[tol1].from=a;edge1[tol1].to=b;edge1[tol1].next=head1[a];edge1[tol1].num=c;head1[a]=tol1++;
}
int find(int x)
{
    if(x!=father[x])
        father[x]=find(father[x]);
    return father[x];
}
void tarjan(int u)
{
    int j,v;
    visit[u]=1;
    father[u]=u;
    //////////////////
    for(j=head1[u];j!=-1;j=edge1[j].next)
    {
        v=edge1[j].to;
        if(visit[v]) LCA[edge1[j].num]=find(v);
    }
    //////////////////
    for(j=head[u];j!=-1;j=edge[j].next)
    {
        v=edge[j].to;
        if(!visit[v]) 
        {
            dis[v]=dis[u]+edge[j].val;
            tarjan(v);
            father[v]=u;
        }
    }
}
int main()
{
    int i,ncase,a,b,c;
    scanf("%d",&ncase);
    while(ncase--)
    {
        scanf("%d%d",&n,&m);
        tol=0;
        memset(head,-1,sizeof(head));
        for(i=1;i<n;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            add(a,b,c);
            add(b,a,c);
        }
        memset(visit,0,sizeof(visit));
        tol1=0;
        memset(head1,-1,sizeof(head1));
        for(i=1;i<=m;i++)
        {
            scanf("%d%d",&a,&b);
            add1(a,b,i);
            add1(b,a,i);
        }
        ///LCA是一种离线算法，所以刚开始需要把所有的询问都输入，然后用邻接表进行存储，i表示第i次询问
        dis[1]=0;
        tarjan(1);
        for(i=0;i<tol1;i+=2)
        {
            a=edge1[i].from;
            b=edge1[i].to;
            c=edge1[i].num;
            printf("%d\n",dis[a]+dis[b]-2*dis[LCA[c]]);
        }
    }
    return 0;
}</span>