hdu 4547 LCA **

题意：在Windows下我们可以通过cmd运行DOS的部分功能，其中CD是一条很有意思的命令，通过CD操作，我们可以改变当前目录。
　　这里我们简化一下问题，假设只有一个根目录，CD操作也只有两种方式：
　　
　　1. CD 当前目录名\...\目标目录名 (中间可以包含若干目录，保证目标目录通过绝对路径可达)
　　2. CD .. (返回当前目录的上级目录)
　　
　　现在给出当前目录和一个目标目录，请问最少需要几次CD操作才能将当前目录变成目标目录？

链接：点我

先返回到根目录，然后直接前进到目标目录

目录刚好成一颗树。

树有唯一的根结点。

每步操作可以到上一级目录，或者直接到下面的目录。

 

其实就是查询LCA

 

要求u->v

把u、v的lca求出来，设为tmp

那么肯定是先u->tmp->u

 

u->temp的步数刚好是他们的深度差，一个数组存深度差就可以了。

 

temp->v如果不相等就是一步，相等就是0步

 #include <iostream>
 #include <string.h>
 #include <algorithm>
 #include <queue>
 #include <map>
 #include <vector>
 #include <math.h>
 #include <string>
 #include <stdio.h>
 #include <math.h>
 using namespace std;
 #define MOD 1000000007
 #define pb(a) push_back(a)
 const int INF=0x3f3f3f3f;
 const double eps=1e-;
 typedef long long ll;
 #define cl(a) memset(a,0,sizeof(a))
 #define ts printf("*****\n");
 const int MAXN=;
 int n,m,ttt;
 int a[MAXN];
 int rmq[*MAXN];//rmq数组，就是欧拉序列对应的深度序列
 struct ST
 {
     int mm[*MAXN];
     int dp[*MAXN][];//最小值对应的下标
     void init(int n)
     {
         mm[] = -;
         for(int i = ;i <= n;i++)
         {
         mm[i] = ((i&(i-)) == )?mm[i-]+:mm[i-];
         dp[i][] = i;
         }
         for(int j = ; j <= mm[n];j++)
         for(int i = ; i + (<<j) -  <= n; i++)
         dp[i][j] = rmq[dp[i][j-]] < rmq[dp[i+(<<(j-))][j-]]?dp[i][j-]:dp[i+(<<(j-))][j-];
     }
     int query(int a,int b)//查询[a,b]之间最小值的下标
     {
         if(a > b)swap(a,b);
         int k = mm[b-a+];
         return rmq[dp[a][k]] <= rmq[dp[b-(<<k)+][k]]?dp[a][k]:dp[b-(<<k)+][k];
     }
 };
 //边的结构体定义
 struct Edge
 {
     int to,next;
 };
 Edge edge[MAXN*];
 int tot,head[MAXN];
 int F[MAXN*];//欧拉序列，就是dfs遍历的顺序，长度为2*n-1,下标从1开始
 int P[MAXN];//P[i]表示点i在F中第一次出现的位置
 int cnt;
 ST st;
 void init()
 {
     tot = ;
     memset(head,-,sizeof(head));
 }
 void addedge(int u,int v)//加边，无向边需要加两次
 {
     edge[tot].to = v;
     edge[tot].next = head[u];
     head[u] = tot++;
 }
 void dfs(int u,int pre,int dep)
 {
     F[++cnt] = u;
     rmq[cnt] = dep;
     P[u] = cnt;
     for(int i = head[u];i != -;i = edge[i].next)
     {
         int v = edge[i].to;
         if(v == pre)continue;
         dfs(v,u,dep+);
         F[++cnt] = u;
         rmq[cnt] = dep;
     }
 }
 void LCA_init(int root,int node_num)//查询LCA前的初始化
 {
     cnt = ;
     dfs(root,root,);
     st.init(*node_num-);
 }
 int query_lca(int u,int v)//查询u,v的lca编号
 {
     return F[st.query(P[u],P[v])];
 }
 bool flag[MAXN];
 int Count_num[MAXN];
 int deep[MAXN];
 vector<int>vc[MAXN];
 map<string,int> mp;
 void bfs(int root)
 {
     cl(deep);
     int now,next;
     queue<int> q;
     q.push(root);
     deep[root]=;
     while(!q.empty())
     {
         now=q.front();
         q.pop();
         for(int i=;i<vc[now].size();i++)
         {
             next=vc[now][i];
             if(deep[next]==)
             {
                 deep[next]=deep[now]+;
                 q.push(next);
             }
         }

     }
 }
 int main()
 {
     int i,j,k;
     #ifndef ONLINE_JUDGE
     freopen("1.in","r",stdin);
     #endif
     scanf("%d",&ttt);
     int ca=;
     while(ttt--)
     {
         scanf("%d%d",&n,&m);
         cl(flag);
         init();
         for(int i=;i<=n;i++)vc[i].clear();
         string u,v;
         mp.clear();
         int tot=;
         char s1[],s2[];
         for(i=;i<n-;i++)
         {
             cin>>u>>v;
             if(mp[u]==)    mp[u]=++tot;
             if(mp[v]==)    mp[v]=++tot;
             int a1=mp[u];
             int a2=mp[v];
             vc[a2].pb(a1);
             addedge(a2,a1);
             addedge(a1,a2);
             flag[a1]=;
         }
         int root;
         for(int i=;i<=n;i++)
             if(!flag[i])
             {
                 root=i;
                 break;
             }
         LCA_init(root,n);
         bfs(root);
         for(i=;i<m;i++)
         {
             cin>>u>>v;
             int a1=mp[u];
             int a2=mp[v];
             int temp=query_lca(a1,a2);
             int ans=deep[a1]-deep[temp];
             if(temp!=a2) ans++;
             printf("%d\n",ans);
         }
     }
 }