hihocoder1069最近公共祖先·三(LCA在线算法--DFS+RMQ-ST)

树上任意两点的最近祖先，必定就是这两个节点的最短路径上深度最小的那个点。

例如：下图中，节点7和5，其最短路径为7--4--1--5, 这条路径上深度最小的点为节点1，其深度为1.节点1即为节点7和5的LCA。

因此，要找到任意两个节点的LCA，只需要先找到上述最短路径，再找到最短路径中深度最小的点。而这下面所述LCA在线算法所做的事。

LCA在线算法描述（以上图为例）：

1.获得“最短路径”（并不是真正的一条路径，包含其他节点，但不影响算法的正确性）

采用DFS遍历整棵树，得到以下数据：

（1）遍历序列p：0　　1　　3　　1　　4　　7　　4　　8　　4　　1　　5　　1　　0　　2　　6　　2　　0

（2）各节点的深度序列　　　　　　　 depth: 0　　1　　 1　　 2　　 2　　2　　 2　　  3　　3

（3）各节点在序列p中首次出现的位置序列pos: 0　　1　　13　　2　　4　　10　　14　　5　　7

有了以上数据，假设现在我们要求节点7和5的最短路径，我们可以这样做：

（1）首先，从pos序列中获得节点7和节点5在p序列中第一次出现的位置分别为：pos[7] = 5, pos[5] = 10;

（2）得到p序列中[5, 10]这一段子序列s：7　　4　　8　　4　　1　　5

（3）s序列中深度最小的点即节点1就是我们要找的节点7和节点5的LCA。

注意到，此时的s序列并非是从节点7到节点5的一条最短路径，它除了包含7到5的最短路径上的节点外，还包含了一些其他的节点，但这些其他的节点都是以节点1为根的子树上的节点，他们的深度都比节点1大，不影响我们算法对正确结果的求解。

2.如何快速的获得一段序列中深度最小的节点

求解区间最值的问题是我们所熟悉的经典的RMQ问题，用RMQ-ST算法即可。由于RMQ-ST算法是在线的，故我们的LCA算法也是在线的。

下面是我的代码实现：

#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

#define MAXN 100005

map<string, int> mp;
string name[2*MAXN];
vector<int> v[2*MAXN];
int p[4*MAXN], depth[2*MAXN], pos[2*MAXN];
int pre_cal[4*MAXN][20];
int cnt, n, m;

void dfs(int i, int d)
{
    pos[i] = cnt;
    p[cnt++] = i;
    depth[i] = d;
    if(v[i].empty()) return;
    for(int j=0; j<v[i].size(); ++j)
    {
        dfs(v[i][j], d+1);
        p[cnt++] = i;
    }
}

void rmq()
{
    for(int i=0; i<4*MAXN; ++i) pre_cal[i][0] = i;
    for(int j=1; (1<<(j-1))<4*MAXN; ++j)
        for(int i=0; i+(1<<(j-1))<4*MAXN; ++i)
                pre_cal[i][j] = depth[p[pre_cal[i][j-1]]]<depth[p[pre_cal[i+(1<<(j-1))][j-1]]]?pre_cal[i][j-1]:pre_cal[i+(1<<(j-1))][j-1];
}

string lca(int a, int b)
{
    int k = floor(log(b-a+1)/log(2));
    int x = pre_cal[a][k], y = pre_cal[b-(1<<k)+1][k];
    return depth[p[x]]<depth[p[y]]?name[p[x]]:name[p[y]];
}

void init()
{
    cnt = 0;
    mp.clear();
    for(int i=0; i<2*MAXN; ++i) v[i].clear();
}

int main()
{
    string name1, name2;
    while(cin>>n)
    {
        init();
        while(n--)
        {
            cin>>name1>>name2;
            if(mp.find(name1)==mp.end())
            {
                mp[name1] = cnt;
                name[cnt++] = name1;
            }
            if(mp.find(name2)==mp.end())
            {
                mp[name2] = cnt;
                name[cnt++] = name2;
            }
            v[mp[name1]].push_back(mp[name2]);
        }
        cnt = 0;
        dfs(0, 0);
        rmq();
        cin>>m;
        while(m--)
        {
            cin>>name1>>name2;
            int a = mp[name1], b = mp[name2];
            cout<<(pos[a]<pos[b]?lca(pos[a], pos[b]):lca(pos[b], pos[a]))<<endl;
        }
    }

    return 0;
}

题目链接：http://hihocoder.com/problemset/problem/1069