hihoder #1069 : 最近公共祖先·三

#1069 : 最近公共祖先·三

时间限制: 10000ms

单点时限: 1000ms

内存限制: 256MB

描述

上上回说到，小Hi和小Ho使用了Tarjan算法来优化了他们的“最近公共祖先”网站，但是很快这样一个离线算法就出现了问题：如果只有一个人提出了询问，那么小Hi和小Ho很难决定到底是针对这个询问就直接进行计算还是等待一定数量的询问一起计算。毕竟无论是一个询问还是很多个询问，使用离线算法都是只需要做一次深度优先搜索就可以了的。

那么问题就来了，如果每次计算都只针对一个询问进行的话，那么这样的算法事实上还不如使用最开始的朴素算法呢！但是如果每次要等上很多人一起的话，因为说不准什么时候才能够凑够人——所以事实上有可能要等上很久很久才能够进行一次计算，实际上也是很慢的！

“那到底要怎么办呢？在等到10分钟，或者凑够一定数量的人两个条件满足一个时就进行运算？”小Ho想出了一个折衷的办法。

“哪有这么麻烦！别忘了和离线算法相对应的可是有一个叫做在线算法的东西呢！”小Hi笑道。

小Ho面临的问题还是和之前一样：假设现在小Ho现在知道了N对父子关系——父亲和儿子的名字，并且这N对父子关系中涉及的所有人都拥有一个共同的祖先（这个祖先出现在这N对父子关系中），他需要对于小Hi的若干次提问——每次提问为两个人的名字（这两个人的名字在之前的父子关系中出现过），告诉小Hi这两个人的所有共同祖先中辈分最低的一个是谁？

提示：最近公共祖先无非就是两点连通路径上高度最小的点嘛！

输入

每个测试点（输入文件）有且仅有一组测试数据。

每组测试数据的第1行为一个整数N，意义如前文所述。

每组测试数据的第2~N+1行，每行分别描述一对父子关系，其中第i+1行为两个由大小写字母组成的字符串Father_i, Son_i，分别表示父亲的名字和儿子的名字。

每组测试数据的第N+2行为一个整数M，表示小Hi总共询问的次数。

每组测试数据的第N+3~N+M+2行，每行分别描述一个询问，其中第N+i+2行为两个由大小写字母组成的字符串Name1_i, Name2_i，分别表示小Hi询问中的两个名字。

对于100%的数据，满足N<=10^5，M<=10^5, 且数据中所有涉及的人物中不存在两个名字相同的人（即姓名唯一的确定了一个人），所有询问中出现过的名字均在之前所描述的N对父子关系中出现过，且每个输入文件中第一个出现的名字所确定的人是其他所有人的公共祖先。

输出

对于每组测试数据，对于每个小Hi的询问，按照在输入中出现的顺序，各输出一行，表示查询的结果：他们的所有共同祖先中辈分最低的一个人的名字。

样例输入

4
Adam Sam
Sam Joey
Sam Micheal
Adam Kevin
3
Sam Sam
Adam Sam
Micheal Kevin

样例输出

Sam
Adam
Adam

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#include<stack>
#include<cmath>
#include<map>
#include<set>

#define L(x) (x<<1)
#define R(x) (x<<1|1)
#define MID(x,y) ((x+y)>>1)
#define bug(x) cout << x << endl;
using namespace std;
#define eps 1e-8
#define N 100005

int orderIndex;
int order[N* 2];
int last[N];
int first[N];
int dep[N];
vector<int>g[N];
string name[N];
map<string, int>mp;
int n;
int m;
int dp[N][32];
int nHave;
void init()
{
    for (int i = 0; i < n; i++)
    {
        g[i].clear();
    }
    mp.clear();
}

void dfs(int u, int d)
{
    dep[u] = d;
    int nLen = g[u].size();
    for (int i = 0; i < nLen; i++)
    {
        int to =g[u][i];
        dp[to][0] = u;
        dfs(to, d+1);
    }
}

void preDeal()
{
    for (int j = 1; (1<<j)<=nHave;j++)
    {
        for (int i = 1; i <= nHave; i++)
            if (dp[i][j-1]!=-1)
                dp[i][j] = dp[dp[i][j-1]][j-1];
    }
}

inline int query(int a, int b)
{
    if(dep[a] < dep[b])
        swap(a, b);

    for (int i = dep[a]; i>=0; i--)
        if (dp[a][i]!=-1 && dep[dp[a][i]]>=dep[b])
        a = dp[a][i];
    if (a == b)
        return a;
    for (int i = dep[a]; i>=0; i--)
    {
        if (dp[a][i] != -1 && dp[b][i] != -1 && dp[a][i]!=dp[b][i])
        {
            a = dp[a][i];
            b = dp[b][i];
        }
    }
    return dp[a][0];
}

int main()
{
    while (~scanf("%d", &n))
    {
        init();
        nHave = 0;
        string fa,son;
        for (int i = 0; i < n; i++)
        {
            cin >> fa >> son;
            if (!mp[fa])
            {
                mp[fa] = ++nHave;
                name[nHave] = fa;
            }
            if (!mp[son])
            {
                mp[son] = ++nHave;
                name[nHave] = son;
            }
            g[mp[fa]].push_back(mp[son]);
        }
        memset(dp, -1, sizeof(dp));
        dfs(1, 1);
        preDeal();
        scanf ("%d", &m);
        while (m--)
        {
            cin >> fa >> son;
            int nFa = mp[fa];
            int nSon = mp[son];
            int pos = query(nFa, nSon);
            cout << name[pos] << endl;
        }
    }
    return 0;
}