neuoj 1632

比较经典的LCA问题，离线算法tarjan和在线算法RMQ都可以搞。

        首先，考虑树上每队点的最短路径的计算，如果确定一个跟root，这里可以随机确定一个根root，那个dist(u,v)=dist(root,u)+dist(root,v)-2*dist(root,LCA(u,v))。也就是说，可以从根做一次深度优先遍历求得每个点到根节点的距离，在做一次LCA,对于每队询问，只要最近公共祖先求出来，那个两个点之间的最短距离也就按上边的公式求出来了。

         值得注意的是，在求LCA中即可把每个点到根节点的距离求出来，基本框架都是深度优先便利。

附上离线LCA的算法模板：

typedeflonglongLL;

constintMAX=0xfffffff;

constintmx=1100000;

structnode{

    intto,next,lca;

    intw;

}edge[mx*2],qedge[mx*2];

inte1,e2;

inthead[mx];

intqhead[mx];

intfa[mx];

intvisit[mx];

intdist[mx];

 

intn,q;

voidinit()

{

    memset(head,-1,sizeof(head));

    memset(qhead,-1,sizeof(qhead));

    memset(visit,0,sizeof(visit));

    memset(dist,MAX,sizeof(dist));

}

voidadd1(inta,intb,intw)

{

    edge[e1].to=b,edge[e1].next=head[a],edge[e1].w=w,head[a]=e1++;

}

voidadd2(inta,intb)

{

    qedge[e2].to=b,qedge[e2].next=qhead[a],qhead[a]=e2++;

}

intfind(intx)

{

    if(fa[x]==x)  returnx;

    fa[x]=find(fa[x]);

    returnfa[x];

}

voidLCA(intu)

{

    fa[u]=u;

    intk;

    visit[u]=true;

    for(k=head[u];k!=-1;k=edge[k].next)

    {

        if(!visit[edge[k].to])

        {

            dist[edge[k].to]=dist[u]+edge[k].w;

            LCA(edge[k].to);

            fa[edge[k].to]=u;

        }

    }

    for(k=qhead[u];k!=-1;k=qedge[k].next)

    {

        if(visit[qedge[k].to])

        {

            qedge[k].lca=find(qedge[k].to);

            qedge[k^1].lca=qedge[k].lca;

        }

    }

}