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

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

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

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

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

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 1000010;
int rmq[2 * MAXN]; //rmq数组，就是欧拉序列对应的深度序列

struct ST {
    int mm[2 * MAXN];
    int dp[2 * MAXN][20]; //最小值对应的下标
    void init(int n) {
        mm[0] = -1;
        for(int i = 1; i <= n; i++) {
            mm[i] = ((i & (i - 1)) == 0) ? mm[i - 1] + 1 : mm[i - 1];
            dp[i][0] = i;
        }
        for(int j = 1; j <= mm[n]; j++)
            for(int i = 1; i + (1 << j) - 1 <= n; i++)
                dp[i][j] = rmq[dp[i][j - 1]] <
                           rmq[dp[i + (1 << (j - 1))][j - 1]] ? dp[i][j - 1] : dp[i + (1 << (j - 1))][j - 1];
    }
    int query(int a, int b) { //查询[a,b]之间最小值的下标
        if(a > b)swap(a, b);
        int k = mm[b - a + 1];
        return rmq[dp[a][k]] <=
               rmq[dp[b - (1 << k) + 1][k]] ? dp[a][k] : dp[b - (1 << k) + 1][k];
    }
};
//边的结构体定义
struct Edge {
    int to, next;
};

Edge edge[MAXN * 2];

int tot, head[MAXN];
int F[MAXN * 2]; //欧拉序列，就是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 = 0;
    memset(head, -1, 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 != -1; i = edge[i].next) {
        int v = edge[i].to;
        if(v == pre)continue;
        dfs(v, u, dep + 1);
        F[++cnt] = u;
        rmq[cnt] = dep;
    }
}
void LCA_init(int root, int node_num) { //查询LCA前的初始化
    cnt = 0;
    dfs(root, root, 0);
    st.init(2 * node_num - 1);
}

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 = 1;
        memset(flag, false, sizeof(flag));
        for(int i = 1; i <= N; i++) {
            //scanf("%d%d", &u, &v);
            cin >> str_u >> str_v;
            if (Hash_zh[str_u] == 0) {
                Hash_fa[cnt] = str_u;
                Hash_zh[str_u] = cnt ++;
            }
            if (Hash_zh[str_v] == 0) {
                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 = 1; i <= N; i++) {
            if(!flag[i]) {
                root = i;
                break;
            }
        }
        LCA_init(root, N);
        int query_n;
        scanf ("%d", &query_n);
        for (int i = 1; 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 0;
}

前天晚上自己重新敲了一版，改用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 << 1]; //结点在出现的顺序数组重复的也要记录
int depth[MAXN << 1]; //结点在搜索树中的深度，与occur相对应
int dp_min[MAXN << 1][20]; //dp_min[i][j] 表示从第i个位置开始的2^j个元素中的最小值的下标
int m = 0; //不断记录出现的下标

void dfs(int u, int deep) {
    occur[++m] = u; //进入该点时进行记录
    depth[m] = deep;
    if(!first[u])
        first[u] = m;
    for(int i = head[u]; i + 1; i = edge[i].next) {
        dfs(edge[i].v, deep + 1);
        occur[++m] = u; //访问子树返回也要标记
        depth[m] = deep;
    }
}
void init() {
    memset(head, -1, sizeof(head));
    e = 0;
}

void RMQ_init(int num) {
    for(int i = 1; i <= num; i++)
        dp_min[i][0] = i; //注意dp_min存的不是最小值，而是最小值的下标
    for(int j = 1; j < 20; j++)
        for(int i = 1; i <= num; i++) {
            if(i + (1 << j) - 1 <= num) {
                dp_min[i][j] = depth[dp_min[i][j - 1]] < depth[dp_min[i + (1 << (j - 1))][j - 1]] ? dp_min[i][j - 1] : dp_min[i + (1 << (j - 1))][j - 1];
            }
        }
}

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 + 1)) / log(2.0));
    int min_id = depth[dp_min[l][k]] < depth[dp_min[r - (1 << k) + 1][k]] ? dp_min[l][k] : dp_min[r - (1 << k) + 1][k]; //最小值下标
    return occur[min_id];//取得当前下标表示的结点
}

map<string, int> Hash_zh;
map<int, string> Hash_fa;

int main() {
    int t, a, b;
    init();
    m = 0;
    memset(first, 0, sizeof(first));
    bool in[MAXN];//记录结点有无入度
    memset(in, false, sizeof(in));
    int u = 0, v = 0, cnt = 1;
    string str_u, str_v;
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) { //注意此题只有n-1条边
        cin >> str_u >> str_v;
        if (Hash_zh[str_u] == 0) {
            Hash_fa[cnt] = str_u;
            Hash_zh[str_u] = cnt ++;
        }
        if (Hash_zh[str_v] == 0) {
            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(1, 0);
    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 0;
}