cf1062e E. Company xdtree+最近公共祖先

最新推荐文章于 2023-02-08 11:59:21 发布

原创最新推荐文章于 2023-02-08 11:59:21 发布 · 267 阅读

0 ·

CC 4.0 BY-SA版权

数据结构专栏收录该内容

99 篇文章

订阅专栏

本文探讨在一棵树中通过线段树维护区间最值来高效求解一堆点的最低公共祖先(LCA)问题，利用DFS序与倍增技巧优化查询过程。

题意：

在一棵树中，每次选择一个区间[l,r]最多删除一个点，使得这个区间内所有点的lca的深度最大。

思路：

首先有一个点，就是一颗树中一堆点的LCA其实就是这堆点DFS序最小和最大的两个点的LCA，线段树维护区间max1,max2,min1,min2,然后倍增求LCA

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <queue>
#include <vector>
using namespace std;

int n,q;
vector<int> e[100005];
int dep[100005];
int tid[100005];
int atid[100005];
int cnt;

int fa[100005][20];
int inf=1e9+7;

void dfs(int u,int d)
{
    cnt++;
    tid[u]=cnt;atid[cnt]=u;dep[u]=d;
    int len=e[u].size();
    for(int i=0;i<len;i++)
    {
        int v=e[u][i];
        dfs(v,d+1);
    }
}

struct node
{
    int l,r;
    int max1,max2;
    int min1,min2;
}tr[100005*5];

node up(node rt,node a,node b)
{
    node ntr=rt;
    if(a.max1>b.max1)
    {
        ntr.max1=a.max1;
        ntr.max2=max(a.max2,b.max1);
    }
    else
    {
        ntr.max1=b.max1;
        ntr.max2=max(a.max1,b.max2);
    }

    if(a.min1<b.min1)
    {
        ntr.min1=a.min1;
        ntr.min2=min(a.min2,b.min1);
    }
    else
    {
        ntr.min1=b.min1;
        ntr.min2=min(a.min1,b.min2);
    }
    return ntr;
}

void build(int i,int l,int r)
{
    tr[i].l=l;tr[i].r=r;
    if(l==r)
    {
        tr[i].max1=tid[l];tr[i].max2=0;
        tr[i].min1=tid[l];tr[i].min2=inf;
    } else
    {
        int mid=(l+r)/2;
        build(i*2,l,mid);build(i*2+1,mid+1,r);
        tr[i]=up(tr[i],tr[i*2],tr[i*2+1]);
    }
}

node get(int i,int l,int r,int ql,int qr)
{
    if(l==ql && r==qr)
        return tr[i];
    else
    {
        int mid=(l+r)/2;
        if(qr<=mid)
            return get(i*2,l,mid,ql,qr);
        else if(ql>mid)
            return get(i*2+1,mid+1,r,ql,qr);
        else
        {
            node ans;
            return up(ans,get(i*2,l,mid,ql,mid),get(i*2+1,mid+1,r,mid+1,qr));
        }
    }
}

int gf(int x,int y)
{
    if(x==y)
        return x;
    else
    {
        if(dep[x]<dep[y])
            swap(x,y);
        for(int i=19;i>=0;i--)
        {
            if(dep[fa[x][i]]>=dep[y])
            {
                x=fa[x][i];
            }
        }
        if(x==y)
            return x;
        for(int i=19;i>=0;i--)
        {
            if(fa[x][i]!=fa[y][i])
            {
                x=fa[x][i];y=fa[y][i];
            }
        }
        return fa[x][0];
    }
}

int main() {

    while(~scanf("%d%d",&n,&q))
    {
        memset(fa,0,sizeof(fa));
        for(int i=0;i<=100001;i++)
        {
            e[i].clear();
        }
        for(int i=2;i<=n;i++)
        {
            int tp;scanf("%d",&tp);
            e[tp].push_back(i);
            fa[i][0]=tp;
        }

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

        cnt=0;
        dfs(1,0);

        build(1,1,n);

        while(q--)
        {
            int l,r;
            scanf("%d%d",&l,&r);
            node ntp=get(1,1,n,l,r);

            int x1=atid[ntp.max1],y1=atid[ntp.min2],ans1=atid[ntp.min1];int anss1=dep[gf(x1,y1)];

            int x2=atid[ntp.max2],y2=atid[ntp.min1],ans2=atid[ntp.max1];int anss2=dep[gf(x2,y2)];

            if(anss1>anss2)
                printf("%d %d\n",ans1,anss1);
            else
                printf("%d %d\n",ans2,anss2);
        }
    }
    return 0;
}