Hdu 4008 Parent and son(给你一棵树(n<=1e5),有Q次查询,每次输入X Y,意思是以X为根,输出Y的儿子节点中节点标号最小和子树中标号最小)

最新推荐文章于 2022-03-06 12:37:24 发布

原创最新推荐文章于 2022-03-06 12:37:24 发布 · 1.8k 阅读

0 ·

CC 4.0 BY-SA版权

树形dp 专栏收录该内容

8 篇文章

订阅专栏

本文介绍了一种基于树形DP的算法实现方案，用于解决特定类型的查询问题。通过构建树形结构并进行深度优先搜索，可以高效地找到节点的子树内节点编号最小值及直接子节点中的最小编号。

题意:
给你一棵树(n<=1e5),有Q次查询,每次输入X Y,意思是以X为根,输出Y的儿子节点中节点标号最小和子树中标号最小

思路:
树形dp
先以1为根
处理出每个子树的最大值和次大值以及每个儿子节点对应的最大值和次大值
~~处理出每个点向上的最小值~~
以1建树就可以不用处理(Y等于1时需要特判)
处理出dfs序

分X的dfs在Y的dfs区间之内和不在区间之内讨论

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+100;
const int INF=0x3f3f3f3f;
struct Edge{
    int to,next;
}e[N*2];
int tot,head[N],L[N],R[N],size[N],sz,fa[N];

void init(){
    tot=0;
    memset(head,-1,sizeof(head));
}

void addedge(int from,int to){
    e[tot]=(Edge){to,head[from]};
    head[from]=tot++;
}

struct node{
    int minv1,minv2,id1,id2;
}a[N],b[N]; //a表示子节点,b表示子树

void getmi(node &tmp,int num,int v){
    if(tmp.minv1>num){
        tmp.minv2=tmp.minv1,tmp.id2=tmp.id1;
        tmp.minv1=num,tmp.id1=v;
    }
    else if(tmp.minv2>num)
        tmp.minv2=num,tmp.id2=v;
}

void dfs(int u,int pre){
    L[u]=++sz;
    a[u].minv1=a[u].minv2=INF,b[u].minv1=b[u].minv2=INF;
    for(int i=head[u];i!=-1;i=e[i].next){
        int v=e[i].to;
        if(v==pre)  continue;
        dfs(v,u),fa[v]=u;
        getmi(a[u],v,v);
        getmi(b[u],min(b[v].minv1,v),v);
    }
    R[u]=sz;
}

int main(){
    int _,n,u,v,q,X,Y;
    scanf("%d",&_);
    while(_--){
        scanf("%d%d",&n,&q);
        init();
        memset(size,0,sizeof(size));
        for(int i=1;i<n;i++){
            scanf("%d%d",&u,&v);
            size[u]++,size[v]++;
            addedge(u,v);
            addedge(v,u);
        }
        sz=0,fa[1]=INF;
        dfs(1,0);
        while(q--){
            scanf("%d%d",&X,&Y);
            if(size[Y]==1)
                printf("no answers!\n");
            else if(L[X]<L[Y]||L[X]>R[Y])
                printf("%d %d\n",a[Y].minv1,b[Y].minv1);
            else{
                int ans=1;
                if(Y==1){
                    if(L[b[Y].id1]<=L[X]&&R[b[Y].id1]>=L[X])
                        ans=b[Y].minv2;
                    else    ans=b[Y].minv1;
                }
                if(L[a[Y].id1]<=L[X]&&R[a[Y].id1]>=L[X])
                    printf("%d %d\n",min(fa[Y],a[Y].minv2),ans);
                else    printf("%d %d\n",min(fa[Y],a[Y].minv1),ans);
            }
        }
        printf("\n");
    }
    return 0;
}