[codevs1036]商务旅行<LCA:tarjan&倍增>

题目链接：http://codevs.cn/problem/1036/

今天翻箱倒柜的把这题翻出来做了，以前做的时候没怎么理解，所以今天来重做一下

这题是一个LCA裸题，基本上就把另一道裸题小机房的树拿出来改一改就行

但LCA也有两种方式，倍增和tarjan，倍增我个人觉得很好理解，tarjan就有点迷了

所以我就用了两种方式打这一道题

倍增：

倍增的做法就是数组f[i][j]表示从i点往上走2^j次方个点可以到达哪个点，

然后进行一个树上倍增，记录下一个深度dep，然后让我们求的两点到同一深度，如果是同一点就return

不是同一点就倍增，倍增这个位置的操作和rmq差不多了，就是找到可以最大跳跃的深度，然后不断找。。直到差一个深度到最近公共祖先

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<iostream>
 #include<cmath>
 #include<stack>
 #include<queue>
 #include<cstdlib>
 #define maxn 30005
 using namespace std;

 struct edge{
     int u,v,nxt;
 }e[maxn*];

 int n,m,a[maxn],now[maxn],f[maxn][];
 int head[maxn],dep[maxn],vis[maxn],ans;

 int tot;
 void adde(int u,int v){
     e[tot]=(edge){u,v,head[u]};
     head[u]=tot++;
 }

 void first(){
     for(int j=;j<=;j++){
         for(int i=;i<=n;i++){
             f[i][j]=f[f[i][j-]][j-];
         }
     }
 }

 void build(int u){
     for(int i=head[u];i!=-;i=e[i].nxt){
         int v=e[i].v;
         if(!vis[v]){
             f[v][]=u;
             dep[v]=dep[u]+;
             vis[v]=;
             build(v);
         }
     }
 }

 int up(int x,int d){
     for(int i=;i<=d;i++)
         x=f[x][];
     return x;
 }

 int find(int x,int y){
     if(dep[x]<dep[y])swap(x,y);//手动使x深度深一些
     if(dep[x]!=dep[y]){
         int dd=dep[x]-dep[y];
         x=up(x,dd);
     }
     if(x==y){return x;}
     for(int j=;j>=;j--){
         if(f[x][j]!=f[y][j]){
             x=f[x][j];y=f[y][j];
         }
     }
     return f[x][];
 }

 int main(){
     memset(head,-,sizeof(head));
     memset(dep,,sizeof(dep));
     scanf("%d",&n);
     for(int i=;i<n;i++){
         int x,y;
         scanf("%d%d",&x,&y);
         adde(x,y);adde(y,x);
     }vis[]=;
     build();
     first();
     scanf("%d",&m);
     now[]=;
     for(int i=;i<=m;i++){
         scanf("%d",&now[i]);
         int lca=find(now[i-],now[i]);
         ans+=dep[now[i-]]+dep[now[i]]-*dep[lca];
     }
     printf("%d",ans);
 }

倍增

tarjan：

虽然有些大佬觉得tarjan比倍增好理解，可能是由于我太弱导致我不能理解tarjan，说实话我觉得tarjan这个算法本身就很迷

tarjan的步骤：

1.判断与u相连的点，如果没来过就继续往深搜索下去

2.用并查集维护u,v的关系，讲两个点合并，将v标记来过

3.查找与u有询问关系的点，如果那个点已经被标记来过就继续

4.这时候找到的v的所属的并查集数组fa[v]储存的就是u,v的最近公共祖先

5.这时候u,v的距离就是u的深度+v的深度-两个最近公共祖先深度

　　dep[u]+dep[v]-2*dep[fa[v]];

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<iostream>
 #include<cmath>
 #include<stack>
 #include<queue>
 #include<cstdlib>
 #define maxn 30005
 using namespace std;

 struct node{
     int u,v,nxt,w;
 }e[maxn*],q[maxn*];

 int ans,n,m,head[maxn],heaq[maxn],dep[maxn];
 int low[maxn],dfn[maxn],fa[maxn],num;
 int now[maxn],cnt,vis[maxn],vise[maxn];

 int tot;
 void adde(int u,int v){
     e[tot]=(node){u,v,head[u],};
     head[u]=tot;tot++;
 }

 int toq;
 void addp(int u,int v,int w){
     q[toq]=(node){u,v,heaq[u],w};
     heaq[u]=toq;toq++;
 }

 int find(int x){
     if(x==fa[x])return x;
     return fa[x]=find(fa[x]);
 }

 void tarjan(int u){
     num++;fa[u]=u;
     dfn[u]=low[u]=num;vis[u]=;
     for(int i=head[u];i!=-;i=e[i].nxt){
         int v=e[i].v;
         if(!dfn[v]){
             dep[v]=dep[u]+;
             tarjan(v);
             fa[v]=u;
         }
     }
     for(int i=heaq[u];i!=-;i=q[i].nxt ){
         int v=q[i].v;
         if(vis[v]&&!vise[q[i].w]){
             vise[q[i].w]=;
             ans+=dep[v]+dep[u]-*dep[find(v)];
         }
     }

 }

 int main(){
     memset(head,-,sizeof(head));
     memset(heaq,-,sizeof(heaq));
     scanf("%d",&n);
     for(int i=;i<n;i++){
         int x,y;
         scanf("%d%d",&x,&y);
         adde(x,y);adde(y,x);
     }
     scanf("%d",&m);
     for(int i=;i<=m;i++){
         scanf("%d",&now[i]);
         if(i==&&now[i]!=)addp(,now[i],i);
         else {
             addp(now[i-],now[i],i);addp(now[i],now[i-],i);
         }
     }dep[]=;
     tarjan();
     printf("%d",ans);
 }

我一个同学教导我，如果你tarjan不理解就画图推，还是推不出来就背就行了，反正又不难背