hicocoder1067 最近公共祖先·二(离线算法tarjan)

tarjan算法是处理最近公共祖先问题的一种离线算法。

算法思路：

先将所有的询问搜集起来。

然后对树进行dfs，在dfs的过程中对节点进行着色。当到达某个节点x的时候，给x着色为灰色，离开x的时候，着色为黑色。

当到达x并将其着色为灰色后，处理与x相关联的所有询问：

（这里有一个显然的事实：所有的灰色节点都是x的祖先）

（1）若询问的另一个节点y是灰色，那么该询问的结果为y；

（2）若询问的另一个节点y是黑色，那么询问结果应为离y最近的y的灰色祖先（因为所有灰色节点都是x的祖先，所以离y最近的y的灰色祖先就是x与y的最近公共祖先了）；

关键在于如何找到离y最近的y的灰色祖先：利用并查集，维护每个节点所属的集合，当某个节点被标记为黑色，就将该节点所在的子树合并到其父节点所属的集合。而灰色节点所属的集合编号就是该节点编号本身。这样我们利用并查集的查找操作就能快速的找到任意黑色节点的最近灰色祖先。

（3）若询问的另一个节点y还没被着色，那么暂不处理，留待访问到y节点的时候再处理。

我的代码：

#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <cstring>

using namespace std;

#define MAXN 100005

map<string, int> mp;
string name[2*MAXN];
vector<int> v[2*MAXN];
vector<int> query[2*MAXN];
map<pair<int, int>, int> qid;
string ans[MAXN];
int color[2*MAXN];
bool flag[MAXN];
int n, m, cnt;
vector<int> v1[MAXN];

struct unionFindSet
{
    int st[2*MAXN];
    void init()
    {
        for(int i=0; i<2*MAXN; ++i)   st[i] = i;
    }
    int findSet(int x)
    {
        if(x==st[x]) return x;
        return st[x] = findSet(st[x]);
    }
    void unionSet(int x, int y)
    {
        int sx = findSet(x), sy = findSet(y);
        st[sx] = sy;
    }
}ufs;

void init()
{
    cnt = 0;
    for(int i=0; i<2*MAXN; ++i) v[i].clear();
    mp.clear();
    for(int i=0; i<2*MAXN; ++i) query[i].clear();
    qid.clear();
    memset(color, 0x11, sizeof(color));
    memset(flag, 0, sizeof(flag));
    for(int i=0; i<MAXN; ++i) v1[i].clear();
    ufs.init();
}

void handleRepetition(int x)
{
    for(int i=0; i<v1[x].size(); ++i)
    {
        ans[v1[x][i]] = ans[x];
        handleRepetition(v1[x][i]);
    }
}

void solute(int x, int y)
{
    if(flag[qid[pair<int, int>(x,y)]]) {}
    else if(color[y]==0)
    {
        ans[qid[pair<int, int>(x,y)]] = name[y];
        flag[qid[pair<int, int>(x,y)]] = true;
    }
    else if(color[y]==1)
    {
        ans[qid[pair<int, int>(x,y)]] = name[ufs.findSet(y)];
        flag[qid[pair<int, int>(x,y)]] = true;
    }
    if(color[y]>=0) handleRepetition(qid[pair<int, int>(x,y)]);
}

void tarjan(int x)
{
    color[x] = 0;
    for(int i=0; i<v[x].size(); ++i)
    {
        tarjan(v[x][i]);
        ufs.unionSet(v[x][i], x);
    }
    for(int i=0; i<query[x].size(); ++i)    solute(x, query[x][i]);
    color[x] = 1;
}

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]);
        }
        cin>>m;
        int id = 0;
        while(m--)
        {
            cin>>name1>>name2;
            query[mp[name1]].push_back(mp[name2]);
            query[mp[name2]].push_back(mp[name1]);
            int tmp = -1;
            if(qid.find(pair<int, int>(mp[name1], mp[name2]))!=qid.end())
                tmp = qid[pair<int, int>(mp[name1], mp[name2])];
            qid[pair<int, int>(mp[name1], mp[name2])] = id++;
            qid[pair<int, int>(mp[name2], mp[name1])] = id-1;
            if(tmp!=-1) v1[id-1].push_back(tmp);
        }
        tarjan(0);
        for(int i=0; i<id; ++i) cout<<ans[i]<<endl;
    }

    return 0;
}

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