[POI 2012]Rendezvous(倍增LCA)

题目链接

http://main.edu.pl/en/archive/oi/19/ran

题目大意

给定一棵内向森林，多次给定两个点a和b，求点对(x,y)满足：

1.从a出发走x步和从b出发走y步会到达同一个点
2.在1的基础上如果有多解，那么要求max(x,y)最小
3.在1和2的基础上如果有多解，那么要求min(x,y)最小
4.如果在1、2、3的基础上仍有多解，那么要求x>=y

思路

很像LCA。。。
定义树根是一个树和有向环相连的那个点
首先如果a和b不在同一内向树的话，肯定无解。我们用并查集来标记每个点在哪个内向树即可(即把有向边当无向边，维护整个图的连通性)

如果a和b在同一个树上的话，两个点最终肯定是走到它们的lca上的

如果a和b不在同一个树，但是在同一个内向树的话，两个点最终要么是走到a所在的树的树根，要么是走到b所在的树的树根，走到其他的点不如这两种情况好。因此我们只需要对两种情况取其中的更优值就好了。

坑爹的是我一开始把lca的预处理打错了。。。结果wa成20分，下了数据对着调才发现问题。。。

我的代码非常不丽洁，膜拜此题80行代码ac的大爷

代码

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>

#define MAXN 510000

using namespace std;

int numofblock=0; //联通块个数
int n,m;
int to[MAXN];

struct edge
{
    int u,v,next;
}edges[MAXN*2];

int head[MAXN],nCount=0;

void AddEdge(int U,int V)
{
    edges[++nCount].u=U;
    edges[nCount].v=V;
    edges[nCount].next=head[U];
    head[U]=nCount;
}

int fa[MAXN][22],depth[MAXN];

void LCA_prework()
{
    for(int j=1;j<20;j++)
        for(int i=1;i<=n;i++)
            fa[i][j]=fa[fa[i][j-1]][j-1];
}

int LCA(int a,int b)
{
    if(depth[a]<depth[b]) swap(a,b);
    for(int i=19;i>=0;i--)
    {
        if(!fa[a][i]) continue;
        if(depth[fa[a][i]]<=depth[b]) continue;
        a=fa[a][i];
    }
    if(depth[a]!=depth[b]) a=fa[a][0];
    if(a==b) return a;
    for(int i=19;i>=0;i--)
    {
        if(!fa[a][i]||!fa[b][i]) continue;
        if(fa[a][i]==fa[b][i]) continue;
        a=fa[a][i],b=fa[b][i];
    }
    a=fa[a][0],b=fa[b][0];
    return a;
}

int belong[MAXN]; //belong[i]=i所在的树的编号(i在树上的话)
int tot=0; //tot=树的个数
int root[MAXN]; //root[i]=点i所在的树的树根
bool vis[MAXN];
bool inRing[MAXN];
int pos[MAXN];
int sizeofring[MAXN]; //sizeofring[i]=基环树i里的环的大小

void DFS(int u)
{
    vis[u]=true;
    if(vis[to[u]])
    {
        inRing[u]=true;
        pos[u]=1;
        for(int i=u;to[i]!=u;i=to[i])
        {
            inRing[to[i]]=true;
            pos[to[i]]=pos[i]+1;
        }
        return;
    }
    DFS(to[u]);
}

void DFS2(int u) //找出连接环的每个树
{
    belong[u]=tot;
    for(int p=head[u];p!=-1;p=edges[p].next)
    {
        int v=edges[p].v;
        if(inRing[v]) continue;
        depth[v]=depth[u]+1;
        fa[v][0]=u;
        DFS2(v);
    }
}

int f[MAXN];

int findSet(int x)
{
    if(f[x]==x) return f[x];
    return f[x]=findSet(f[x]);
}

int main()
{
    for(int i=0;i<MAXN;i++) f[i]=i;
    memset(head,-1,sizeof(head));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&to[i]);
        AddEdge(to[i],i);
        f[findSet(to[i])]=f[findSet(i)];
    }
    for(int t=1;t<=n;t++)
    {
        if(vis[t]) continue;
        if(f[t]==t) DFS(t);
    }
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=n;i++)
        if(inRing[i])
        {
            tot++;
            root[tot]=i;
            DFS2(i);
        }
    memset(vis,false,sizeof(vis));
    for(int i=1;i<=n;i++)
    {
        int blocknum=findSet(i);
        if(inRing[i]&&!vis[blocknum])
        {
            vis[blocknum]=true;
            sizeofring[blocknum]=max(sizeofring[blocknum],pos[i]);
            for(int j=i;to[j]!=i;j=to[j])
                sizeofring[blocknum]=max(sizeofring[blocknum],pos[to[j]]);
        }
    }
    LCA_prework();
    for(int i=1;i<=m;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        if(f[findSet(a)]!=f[findSet(b)])
        {
            printf("-1 -1\n");
            continue;
        }
        if(a==b)
        {
            printf("0 0\n");
            continue;
        }
        if(belong[a]==belong[b]&&findSet(a)==findSet(b))
        {
            int lca=LCA(a,b);
            printf("%d %d\n",depth[a]-depth[lca],depth[b]-depth[lca]);
            continue;
        }
        int roota=root[belong[a]],rootb=root[belong[b]],blocknum=findSet(a);
        int x1=depth[a],y1=depth[b]+(pos[roota]-pos[rootb]+sizeofring[blocknum])%sizeofring[blocknum];
        int x2=depth[a]+(pos[rootb]-pos[roota]+sizeofring[blocknum])%sizeofring[blocknum],y2=depth[b];
        int ansx=0,ansy=0;
        if(max(x1,y1)!=max(x2,y2))
        {
            if(max(x1,y1)<max(x2,y2))
            {
                ansx=x1;
                ansy=y1;
            }
            else
            {
                ansx=x2;
                ansy=y2;
            }
        }
        else if(min(x1,y1)!=min(x2,y2))
        {
            if(min(x1,y1)<min(x2,y2))
            {
                ansx=x1;
                ansy=y1;
            }
            else
            {
                ansx=x2;
                ansy=y2;
            }
        }
        else
        {
            if(x1>=y1)
            {
                ansx=x1;
                ansy=y1;
            }
            else
            {
                ansx=x2;
                ansy=y2;
            }
        }
        printf("%d %d\n",ansx,ansy);
    }
    return 0;
}