【hihoCoder第十五周】最近公共祖先·二

老实说我没有读题，看见标题直接就写了，毕竟hiho上面都是裸的算法演练。

大概看了下输入输出，套着bin神的模板，做了个正反map映射，但是怎么都得不了满分。等这周结束后，找高人询问下trick。

若是有人找出了错误，或是发现代码中的不足，求指出。感激！~

以下是个人80分的代码。（之后献上两天之后的100分代码~_~）。

 #include <bits/stdc++.h>
 using namespace std;
 
 const int 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;
 map<string, int> Hash_zh;
 map<int, string> Hash_fa;
 
 void init() {
     tot = ;
     memset(head, -, sizeof(head));
     Hash_zh.clear();
     Hash_fa.clear();
 }
 
 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 main() {
     int T, N;
     int u, v, cnt;
     string str_u, str_v;
     while(~scanf("%d", &N)) {
         init();
         cnt = ;
         memset(flag, false, sizeof(flag));
         for(int i = ; i <= N; i++) {
             //scanf("%d%d", &u, &v);
             cin >> str_u >> str_v;
             if (Hash_zh[str_u] == ) {
                 Hash_fa[cnt] = str_u;
                 Hash_zh[str_u] = cnt ++;
             }
             if (Hash_zh[str_v] == ) {
                 Hash_fa[cnt] = str_v;
                 Hash_zh[str_v] = cnt ++;
             }
             u = Hash_zh[str_u];
             v = Hash_zh[str_v];
             addedge(u, v);
             addedge(v, u);
             flag[v] = true;
         }
         int root;
         for(int i = ; i <= N; i++) {
             if(!flag[i]) {
                 root = i;
                 break;
             }
         }
         LCA_init(root, N);
         int query_n;
         scanf ("%d", &query_n);
         for (int i = ; i <= query_n; ++ i) {
             //scanf("%d%d", &u, &v);
             cin >> str_u >> str_v;
 
             if (str_u == str_v) {
                 cout << str_u << endl;
                 continue;
             }
 
             u = Hash_zh[str_u];
             v = Hash_zh[str_v];
             cout << Hash_fa[query_lca(u, v)] << endl;
         }
     }
     return ;
 }

前天晚上自己重新敲了一版，改用struct来存树，结果新代码直接就A掉了，但是还是不知道原来的问题。毕竟想法没错。仍旧是DFS + RMQ的ST。

 #include <bits/stdc++.h>
 
 using namespace std;
 
 #define MAXN 100005
 #define MAXM 105
 #define inf 0x7ffffff
 int n;
 struct Edge {
     int v, next;
 } edge[MAXN];
 int head[MAXN];
 int e;
 
 void addEdge(int u, int v) { //加边
     edge[e].v = v;
     edge[e].next = head[u];
     head[u] = e++;
 }
 int first[MAXN];//结点在搜索顺序数组中最先出现的位置（下标）
 int occur[MAXN << ]; //结点在出现的顺序数组重复的也要记录
 int depth[MAXN << ]; //结点在搜索树中的深度，与occur相对应
 int dp_min[MAXN << ][]; //dp_min[i][j] 表示从第i个位置开始的2^j个元素中的最小值的下标
 int m = ; //不断记录出现的下标
 
 void dfs(int u, int deep) {
     occur[++m] = u; //进入该点时进行记录
     depth[m] = deep;
     if(!first[u])
         first[u] = m;
     for(int i = head[u]; i + ; i = edge[i].next) {
         dfs(edge[i].v, deep + );
         occur[++m] = u; //访问子树返回也要标记
         depth[m] = deep;
     }
 }
 void init() {
     memset(head, -, sizeof(head));
     e = ;
 }
 
 void RMQ_init(int num) {
     for(int i = ; i <= num; i++)
         dp_min[i][] = i; //注意dp_min存的不是最小值，而是最小值的下标
     for(int j = ; j < ; j++)
         for(int i = ; i <= num; i++) {
             if(i + ( << j) -  <= num) {
                 dp_min[i][j] = depth[dp_min[i][j - ]] < depth[dp_min[i + ( << (j - ))][j - ]] ? dp_min[i][j - ] : dp_min[i + ( << (j - ))][j - ];
             }
         }
 }
 
 int RMQ_min(int a, int b) {
     int l = first[a], r = first[b]; //得到区间左右端点
     if(l > r) {
         int t = l;
         l = r;
         r = t;
     }
     int k = (int)(log(double(r - l + )) / log(2.0));
     int min_id = depth[dp_min[l][k]] < depth[dp_min[r - ( << k) + ][k]] ? dp_min[l][k] : dp_min[r - ( << k) + ][k]; //最小值下标
     return occur[min_id];//取得当前下标表示的结点
 }
 
 map<string, int> Hash_zh;
 map<int, string> Hash_fa;
 
 int main() {
     int t, a, b;
     init();
     m = ;
     memset(first, , sizeof(first));
     bool in[MAXN];//记录结点有无入度
     memset(in, false, sizeof(in));
     int u = , v = , cnt = ;
     string str_u, str_v;
     scanf("%d", &n);
     for(int i = ; i <= n; i++) { //注意此题只有n-1条边
         cin >> str_u >> str_v;
         if (Hash_zh[str_u] == ) {
             Hash_fa[cnt] = str_u;
             Hash_zh[str_u] = cnt ++;
         }
         if (Hash_zh[str_v] == ) {
             Hash_fa[cnt] = str_v;
             Hash_zh[str_v] = cnt ++;
         }
         u = Hash_zh[str_u];
         v = Hash_zh[str_v];
         addEdge(u, v); //u->v单向
         //in[v] = true;
     }
     dfs(, );
     RMQ_init(m);
     int op_n;
     scanf ("%d", &op_n);
     while (op_n --) {
         cin >> str_u >> str_v;
         if (str_u == str_v) {
             cout << str_u << endl;
             continue;
         }
         u = Hash_zh[str_u];
         v = Hash_zh[str_v];
         cout << Hash_fa[RMQ_min(u, v)] << endl;
     }
 
     return ;
 }