hiho刷题日记——第十五最近公共祖先·二

最新推荐文章于 2015-12-18 21:12:42 发布

原创最新推荐文章于 2015-12-18 21:12:42 发布 · 688 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#最近公共祖先 #并查集 #深度优先遍历 #离线算法

hihocoder 专栏收录该内容

31 篇文章

订阅专栏

本文探讨了在大型家族关系数据集中查询最近公共祖先的问题，通过使用邻接表构建家族树，并结合离线算法和并查集优化查询效率。通过深度优先遍历家族树，标记节点和边来快速定位最近公共祖先，显著提高了查询速度。

题目

与最近公共祖先·一
将设置关系数量和查询关系数量的数量级都从100提升到100000。

思路

用邻接表，将家族关系建树，查询情况建图。
使用离线算法的方式，通过一次深度优先遍历家族树，得出所有查询的答案。
遍历时，第一次访问结点，将该节点做个标记1。访问完结点的所有子结点时，标记为2。
在遍历到一个节点时，在查询图中扫描所有该节点的边，检查边的另一个端点的标记。若标记为0，无视；若标记为1，则说明该节点是另一个端点在家族树中的子节点，最近公共祖先便为另一个端点；若标记为2，则说明，从另一端点追查到的第一个标记为1的祖先，是他们的最近公共祖先。

优化

加上并查集。

代码

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

using namespace std;
const int MAX_SIZE=100000+5;
int N;
int fa[MAX_SIZE],color[MAX_SIZE];
int head_q[MAX_SIZE],head_t[MAX_SIZE],e_q=0,e_t=0;
int ans[MAX_SIZE<<1];
map<string,int> s_id;
map<int,string> id_s;

struct EDGE
{
    int v,next;
}edge_q[MAX_SIZE<<1],edge_t[MAX_SIZE];

void addEdge_t(int x,int y)
{
    edge_t[e_t].v=y;
    edge_t[e_t].next=head_t[x];
    head_t[x]=e_t++;
}

void addEdge_q(int x,int y)
{
    edge_q[e_q].v=y;
    edge_q[e_q].next=head_q[x];
    head_q[x]=e_q++;
}

int find_fa(int x)
{
    if(x!=-1 && color[x]==2) return fa[x]=find_fa(fa[x]);
    return x;
}

void dfs(int cur)
{
    color[cur]++;
    int p=head_q[cur];
    while(p!=-1)
    {
        if(color[edge_q[p].v] == 1) 
        {
            ans[p]=edge_q[p].v;
            if(p%2) ans[p-1]=ans[p];
            else ans[p+1]=ans[p];
        }
        if(color[edge_q[p].v] == 2) 
        {
            ans[p]=find_fa(edge_q[p].v);
            if(p%2) ans[p-1]=ans[p];
            else ans[p+1]=ans[p];
        }
        p=edge_q[p].next;
    }
    p=head_t[cur];
    while(p!=-1)
    {
        dfs(edge_t[p].v);
        p=edge_t[p].next;
    }
    color[cur]++;
}

int main()
{
    memset(head_q,-1,sizeof(head_q));
    memset(head_t,-1,sizeof(head_t));
    memset(fa,-1,sizeof(fa));
    memset(color,0,sizeof(color));
    int id=0;
    string fn,sn;
    scanf("%d",&N);
    while(N--)
    {
        cin>>fn>>sn;
        if(!s_id.count(fn)) 
        {
            s_id[fn]=id;
            id_s[id]=fn;
            id++;
        }
        if(!s_id.count(sn))
        {
            s_id[sn]=id;
            id_s[id]=sn;
            id++;
        }
        addEdge_t(s_id[fn],s_id[sn]);
        fa[s_id[sn]]=s_id[fn];
    } 

    scanf("%d",&N);
    while(N--)
    {
        cin>>fn>>sn;
        addEdge_q(s_id[fn],s_id[sn]);
        addEdge_q(s_id[sn],s_id[fn]);
    }

    dfs(0);
    for(int i=0;i<e_q;i+=2)
    {
        cout<<id_s[ans[i]]<<endl;
    }

    return 0;
}