#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对父子关系中出现过，且每个输入文件中第一个出现的名字所确定的人是其他所有人的公共祖先。

输出

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

样例输入

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

样例输出

Sam
Adam

Adam



题解：通过dfs得到数组：ABDBEBACA

          每个节点第一次访问的数组下标：1，2，3，5，8

          数组节点的深度：1,2,3,2,3,2,1,2,1

          找D，C最近祖先：数组中D到C之间深度最低的是A，最近祖先是A。

         找D，E最近祖先：数组中D到E之间深度最低的是B，最近祖先是B。

      查找过程是在数组中查找一段序列的最值，所以联想到RMQ算法。RMQ算法就是解决数组中i，j之间最值得算法。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <map>
#include <vector>
#include <cmath>

using namespace std;

const int maxn = 100005;

int first[maxn];           //保存该人第一次访问出现的顺序
int deep[2 * maxn];       //该点的深度
int vex[2 * maxn];        //每个顺序表示的编号
int dp[maxn][20];        //保存最近祖先的在数组中的下标，不能保存深度最小的，因为通过深度得不到该点数组下标，就不用说编号了
map<string,int> mp;      //给每一个人赋值一个编号
string name[maxn];      //用编号保存名字
vector<int> vec[maxn];  //保存儿子
int cnt = 0;            //编号用到
int k = 0;              //数组下标

void dfs(int x,int dep)     //得到数组
{
vex[++k] = x;           //这里肯定访问的是新节点,因为for循环只会继续下一个未访问的节点
deep[k] = dep;
first[x] = k;           //所以第一次访问肯定是这里
for(int i = 0;i < vec[x].size();i++)
{
dfs(vec[x][i],dep + 1);
vex[++k] = x;       //访问儿子之后又访问自己
deep[k] = dep;
}
}

void RMQ()
{
for(int i = 1;i <= k;i++)     //dp[i][j]保存的是深度最小的那一个的下标
{
dp[i][0] = i;             //下标为i的数组往后1位深度最小的就是自己
}
int a,b;
for(int i = 1;i <  20;i++)      //20足够了
{
for(int j = 1;j <= k;j++)
{
if(j + (1 << i) - 1 <= k)
{
a = dp[j][i - 1];
b = dp[j + (1 << (i - 1))][i - 1];
dp[j][i] = deep[a] > deep[b] ? b : a;   //得到深度最小的数组下标
}
}
}
}

void query(string& name1,string& name2)     //询问
{
int b = max(first[mp[name1]],first[mp[name2]]);  //表示第一次访问的节点数组下标较大的一个
int a = min(first[mp[name1]],first[mp[name2]]);
int k = log2(b - a + 1);                         //2的k次方可能不能包含b-a-1个数
int c = dp[a][k];
int d = dp[b - (1 << k) + 1][k];
int res = deep[c] > deep[d] ? d : c;             //得到深度最小的那一个的下标
cout<<name[vex[res]]<<endl;	                     //通过编号得到结果
}

int solve(string& s)             //给每一个字符串一个不同的编号，相当于不同的人
{
if(mp.count(s) != 0)
{
return mp[s];
}

name[++cnt] = s;            //通过编号保存人名
return mp[s] = cnt;
}

int main()
{
int ncase;
string name1,name2;
int m,n;
int f,s;
cin>>m;
for(int i = 0;i < m;i++)
{
cin>>name1>>name2;
f = solve(name1);
s = solve(name2);
vec[f].push_back(s);     //保存儿子
}

dfs(1,1);
RMQ();
cin>>n;
while(n--)
{
cin>>name1>>name2;
query(name1,name2);
}

mp.clear();
for(int i = 0;i < maxn;i++)
{
vec[i].clear();
}

return 0;
}