【HDU 4547 CD操作】LCA问题 Tarjan算法

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4547

题意：模拟DOS下的cd命令，给出n个节点的目录树以及m次查询，每个查询包含一个当前目录cur和一个目标目录tar，返回从cur切换到tar所要使用的cd命令次数：

注意这里的cd命令是简化版，只能进行如下两种操作：

　　1. cd   ..                                        //返回父目录

　　2. cd   cur\一系列目录\tar                 //由当前目录跳转到目标目录，注意中间的“一系列目录”不能包含父目录..，也就是说，自底向上必须一步步走，而自顶向下可以一步到位。

思路：用Tarjan算法求LCA，处理查询时要分类讨论：

　　1. if tar == lca，则res(cur, tar) = depth(cur) - depth(lca); （包含tar == cur的情况）

　　2. else if cur == lca, 则res(cur, tar) = 1;

　　3. 其他，则res(cur, tar) = depth(cur) - depth(lca) + 1;

这道题还有些细节问题需要处理好：

1. 每个查询要记录好目标目录是谁。因为tarjan算法是批处理的，即每完成对一个棵子树的遍历，处理其树根所涉及到的查询。为使查询处理不遗漏，我们把查询也以邻接表的形式存成双向边，然而每次处理需要知道本次查询原始的“单向边”，这样才能根据上面的分类计算结果。所以我另设了一个数组ans_tar[i]记录第 i 个查询所给定的tar。

2. 同HDU2586这道题，多个查询，注意记录查询序列号。这道题我用邻接表项query_id[r][i]记录节点r的第i个查询所持有的查询序列号，用邻接表项query_tar[r][i]记录节点r的第i个查询的目标节点。

3. 给出的目录是字符串，要用一个map<string, int>存储名称到节点号的映射关系。

　这里又了解到了map一个用法，即对[]的重载：对于map<string, int> m，如果调用一次m[s]，而s在m中不存在时，会自动插入s并将它的value置为0。这个设计对于这道题很合适，可以维护全局计数变量seq_num，如果返回0的话，分发下一个序号给它即可。

 #include <cstdio>
 #include <iostream>
 #include <vector>
 #include <map>
 #include <string>
 #include <cstring>
 using namespace std;
 const int MAX_N = ;
 const int MAX_M = ;

 int vis[MAX_N];
 int ans[MAX_N];
 int ans_tar[MAX_N];//每组查询的目标目录
 int indeg[MAX_N];
 int depth[MAX_N];
 map<string, int> name;
 vector<int> G[MAX_N];//邻接表，边不带权
 vector<int> query_tar[MAX_N];
 vector<int> query_id[MAX_N];
 int par[MAX_N];

 int T;
 int n, m;
 int seq_num;//目录名的序列号，从1开始

 void init(){
     seq_num = ;
     memset(vis, , sizeof(vis));
     memset(ans, , sizeof(ans));
     memset(ans_tar, , sizeof(ans_tar));
     memset(indeg, , sizeof(indeg));
     memset(depth, , sizeof(depth));
     name.clear();
     for(int i=; i<MAX_N; i++){
         G[i].clear();
         query_tar[i].clear();
         query_id[i].clear();
         par[i] = i;
     }
 }
 int find(int x){
     return par[x]==x ? x : par[x] = find(par[x]);
 }
 void unite(int x, int y){
     x = find(x);
     y = find(y);
     if(x==y) return ;
     par[y] = x;
 }

 void dfs(int r, int l){
     //cout << "dfs " << r << endl;
     vis[r] = ;
     depth[r] = l;
     for(int i=; i<G[r].size(); i++){
         //cout << G[r][i] << endl;
         if(vis[G[r][i]]) continue;
         dfs(G[r][i], l+);
         unite(r, G[r][i]);
     }
     for(int i=; i<query_tar[r].size(); i++){
         if(!vis[query_tar[r][i]]) continue;
         int cur, tar;
         int ans_id = query_id[r][i];//这一查询所持的序列号
         int real_tar = ans_tar[ans_id];//这一个查询真正指定的target
         if(r == real_tar){//当前r是目标
             cur = query_tar[r][i];
             tar = real_tar;
         }else{//已访问过的那个点是目标
             cur = r;
             tar = real_tar;
         }
         //cout << "query " << cur << tar << endl;
         int ca = find(query_tar[r][i]);
         if(tar == ca) ans[ans_id] = depth[cur] - depth[ca];
         else if(cur == ca) ans[ans_id] = ;
         else ans[ans_id] = depth[cur] - depth[ca] + ;
     }
 }

 void lca(int r){
     //cout << "root " << r << endl;
     dfs(r, );
 }

 int main()
 {
     freopen("4547.txt", "r", stdin);
     scanf("%d", &T);
     while(T--){
         init();
         scanf("%d%d", &n, &m);
         for(int i=; i<n-; i++){
             string c, p;
             cin>>c;
             int u = name[c];//不存在会自动插入并置value为0
             if(u==){
                 u = name[c] = seq_num++;
             }

             cin>>p;
             int v = name[p];
             if(v==){
                 v = name[p] = seq_num++;
             }
             G[u].push_back(v);
             G[v].push_back(u);
             indeg[u]++;//入度为0的是根目录
         }
         // for(map<string, int>::iterator iter = name.begin();
         //     iter != name.end(); iter++){
         //     cout << iter->first << iter->second << endl;
         // }
         for(int i=; i<m; i++){
             string cur, tar;
             cin >> cur >> tar;
             int u = name[cur];
             int v = name[tar];
             query_tar[u].push_back(v);
             query_tar[v].push_back(u);
             query_id[u].push_back(i);//tar和id是同步记录的
             query_id[v].push_back(i);
             ans_tar[i] = v;//为辨谁是目标目录
         }
         for(map<string, int>::iterator iter = name.begin();
             iter != name.end(); iter++){
             int id = iter->second;
             if(indeg[id] == ){
                 lca(id);
                 break;
             }
         }
         for(int i=; i<m; i++){
             printf("%d\n", ans[i]);
         }
     }
     return ;
 }