HDU4008 Parent and son

　　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.csdn.net/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();
    }
}