HDU4008 Parent and son-优快云博客

本文提供了一个解决树形结构中查询特定节点的最小儿子和最小子孙值的算法，通过预处理和二分查找实现O(1)时间复杂度的高效查询。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

　　HDU4008 Parent and son

Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 65768/65768 K (Java/Others)
Total Submission(s): 1035 Accepted Submission(s): 249

Problem Description

Give you a tree with N vertices and N‐ 1 edges, and then ask you Q queries on “which vertex is Y's son that has the smallest number and which vertex is Y’s descendants that has the smallest number if we choose X as the root of the entire tree?”

Input

The first line of input is an integer T (T<=10) means the case number.
The first line of each test case contains N(2 ≤ N ≤ 100,000) and Q(1 ≤ Q ≤ 100,000).
Each of the following N ‐ 1 lines of the test case contains two integers a(1 ≤ a ≤ N) and b(1 ≤ b ≤ N) indicating an edge between a and b.
Each of the following Q lines of the test case contains two integers X(1 ≤ X ≤ N) and Y(1 ≤ Y ≤ N, Y ≠ X) indicating an query.

Output

For each query, output the Y's son which has the smallest number and Y's descendant that has the smallest number if X is the root of the entire tree. If Y has no sons then output “no answers!”. There is an empty line after each case.

Sample Input

   1 7 3 1 2 1 5 2 3 2 4 5 6 5 7 1 2 5 3 3 2
  

Sample Output

   3 3 no answers! 1 1
  

Source

The 36th ACM/ICPC Asia Regional Dalian Site —— Online Contest

**************************************************************

题目大意：给你一棵树，这个树的根节点不定。然后有Q次询问。对于每次询问，给定x和y。即当整棵树以x为根的时候，求y的所有儿子中最小的那个编号值以及y的所有

子孙中最小的编号值。

解题思路： http://blog.youkuaiyun.com/hqd_acm/article/details/6750163我主要是参考了一篇文章，思路是他的，实现是我的。

还有不得不说的神乎其神的dfn时间戳数组。初识dfn数组是在前几天的图的连通性问题中见识到，当时觉得一个时间戳竟然如此好用。今天更感其神啊。当dfs一棵树的时候，

我们可以递归得到一个节点他是所有子孙中的最大的时间戳，把这个也记录下来。然后奇迹啊！我们可以在o(1)的时间内判断y是不是在x的子树下面。

其他的看那篇博客就好了。

本人代码附上：

#include <stdio.h>
#include <string.h>
#include <vector>
#include <algorithm>
#define MIN(a,b) ((a)<(b)?(a):(b))
#define MAX(a,b) ((a)>(b)?(a):(b))
#define INF 0x3f3f3f3f
#define N 100005
using namespace std;

vector<int>gra[N],ht;
int mindown[N],fa[N],minson[N][2],dfn[N],now,maxdfn[N];
int n,m;
/*mindown数组用来储存每个节点以下最小的子孙的值，fa数组储存每个节点的
父亲值，minson的两个值分别是每个节点下的最小和次小的儿子值，dfn神乎其神
的时间戳数组，now用来盖印时间戳，maxdfn数组用来储存每个节点子孙中的最大
的dfn值*/

void ini(void)//初始化
{
    memset(fa,0,sizeof(fa));
    memset(dfn,0,sizeof(dfn));
    memset(maxdfn,0,sizeof(maxdfn));
    now=0;
    for(int i=1;i<=n;i++)
        gra[i].clear();
}

void dfs(int s,int f)//预处理
{
    fa[s]=f;
    dfn[s]=maxdfn[s]=++now;
    ht.clear();
    mindown[s]=minson[s][0]=minson[s][1]=INF;
    for(int i=0;i<gra[s].size();i++)
        if(!fa[gra[s][i]])
            ht.push_back(gra[s][i]);
    gra[s]=ht;
    for(int i=0;i<gra[s].size();i++)
    {
        int t=gra[s][i];
        dfs(t,s);
        mindown[s]=MIN(mindown[s],t);
        mindown[s]=MIN(mindown[s],mindown[t]);
        if(t<minson[s][0])
            minson[s][1]=minson[s][0],minson[s][0]=t;
        else if(t<minson[s][1])
            minson[s][1]=t;
        maxdfn[s]=MAX(maxdfn[s],maxdfn[t]);
    }
}

int erfen(int x,int y)//二分查找儿子
{
    int le=0,ri=gra[y].size(),mid;
    while(1)
    {
        mid=(le+ri)>>1;
        if(dfn[x]>=dfn[gra[y][mid]]&&dfn[x]<=maxdfn[gra[y][mid]])return gra[y][mid];
        if(dfn[x]>maxdfn[gra[y][mid]])le=mid+1;
        if(dfn[x]<dfn[gra[y][mid]])ri=mid-1;
    }
}

void re(void)//输入
{
    scanf("%d%d",&n,&m);
    ini();
    for(int i=1;i<n;i++)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        gra[a].push_back(b);
        gra[b].push_back(a);
    }
}

void run(void)//运行
{
    dfs(1,-1);
    int temp[2]={INF,INF};//temp表示1节点儿子中mindown的最小值和次小值
    for(int i=0;i<gra[1].size();i++)
    {
        int t=gra[1][i];
        if(mindown[t]<temp[0])
            temp[1]=temp[0],temp[0]=mindown[t];
        else if(mindown[t]<temp[1])
            temp[1]=mindown[t];
    }
    for(int h=1;h<=m;h++)//m次询问
    {
        int x,y;
        scanf("%d%d",&x,&y);
        int fx=-1,fy=-1;
        if(dfn[x]>dfn[y]&&dfn[x]<=maxdfn[y])//在o(1)的时间内知道x是不是y的子孙
            fx=erfen(x,y);
        if(dfn[y]>dfn[x]&&dfn[y]<=maxdfn[x])
            fy=erfen(y,x);
        if(fx==-1)//要么y是x的子孙，要么y和x不在一棵子树上面
        {
            if(mindown[y]==INF)printf("no answers!\n");
            else printf("%d %d\n",minson[y][0],mindown[y]);
        }
        else//x是y的子孙，当y是否等于1的时候有特殊处理
        {
            if(y!=1)
            {
                if(fx!=minson[y][0])
                    printf("%d %d\n",MIN(minson[y][0],fa[y]),1);
                else
                {
                    if(gra[y].size()==1)
                        printf("%d %d\n",fa[y],1);
                    else
                        printf("%d %d\n",MIN(minson[y][1],fa[y]),1);
                }
            }
            else
            {
                if(gra[y].size()==1)
                    printf("no answers!\n");
                else
                {
                    int a=temp[0];
                    if(a!=INF&&dfn[a]>=dfn[fx]&&dfn[a]<=maxdfn[fx])
                            a=temp[1];
                    int b=minson[1][0];
                    if(fx==minson[1][0])
                        b=minson[1][1];
                    printf("%d %d\n",b,MIN(a,b));
                }
            }
        }
    }
    puts("");
}

int main()
{
    int ncase;
    scanf("%d",&ncase);
    while(ncase--)
    {
        re();
        run();
    }
}

转载于:https://www.cnblogs.com/Fatedayt/archive/2011/09/21/2184396.html