UVALive 3486/zoj 2615 Cells（栈模拟dfs）

这道题在LA是挂掉了，不过还好，zoj上也有这道题。

题意：好大一颗树，询问父子关系。。考虑最坏的情况，30w层，2000w个点，询问100w次，貌似连dfs一遍都会TLE。

安心啦，这肯定是一道正常人能做的题目。不过是需要几个小技巧。

1、2000w个点不一定都要保存下来，事实上，虽然题目给了256M的空间，只要开了两个这么大的数组，MLE是跑不了的，所以只保存30w个父节点。

2、如果这30w个父节点构成一条链，dfs的栈肯定爆。所以需要用栈模拟dfs。这里用的是stack<int>，当然手写栈会更快。

注意：1、时间戳的使用。

　　  2、本题中顺序对节点标号，使得所有>=n的节点都是叶子节点，同时能够二分也是因为它是有序的。

#include<cstdio>
#include<cstring>
#include<stack>
#include<algorithm>
using namespace std;

const int MAXN=333333;

struct Point{
    int l,r;
}point[MAXN];

struct T{
    int in,out;
}tim[MAXN];

int child[MAXN],dfs_clock;
stack<int>stk;

void init()
{
    dfs_clock=0;
    while(!stk.empty())
        stk.pop();
}

void dfs(int n)
{
    init();
    stk.push(0);
    tim[0].in=++dfs_clock;
    child[0]=1;            
    while(!stk.empty())
    {
        int x=stk.top();
        int r=point[x].r;
        if(child[x]>r||child[x]>=n){
            tim[x].out=++dfs_clock;
            stk.pop();
        }else {
            stk.push(child[x]);
            tim[child[x]].in=++dfs_clock;
            child[child[x]]=point[child[x]].l;
            child[x]++;
        }
    }
}

int find(int x,int n)//找父节点：利用顺序编码进行二分 
{
    int l=0,r=n-1;
    while(l<r)
    {
        
        int m=l+(r-l+1)/2;
        if(point[m].l<=x&&point[m].r>=x)
            return m;
        if(point[m].l>x)
            r=m-1;
        else
            l=m;
    }
    return l;
}

int main()
{
    int TT;
    scanf("%d",&TT);
    
        int n;
        for(int cas=1;cas<=TT;cas++)
        {
            scanf("%d",&n);
            int x,y=1;
            for(int i=0;i<n;i++)
            {
                scanf("%d",&x);
                point[i].l=y;
                point[i].r=y+x-1;
                y+=x;
            }

            dfs(n);
            
            int m,u,v,pv;
            scanf("%d",&m);
            printf("Case %d:
",cas);
            int flog;
            for(int i=0;i<m;i++)
            {
                flog=0;
                scanf("%d%d",&u,&v);
                
                if(u<n&&v<n){
                    if(tim[u].in<tim[v].in&&tim[u].out>tim[v].out)
                        flog=1;
                }
                else if(u<n&&v>=n){//u<n漏掉了，导致RE；若u>=n，那么u就是叶子节点，不可能是父亲 
                    pv=find(v,n);
                    if(tim[u].in<=tim[pv].in&&tim[u].out>=tim[pv].out)
                        flog=1;
                }
                
                if(flog)
                    printf("Yes
");
                else 
                    printf("No
");
            }
            if(cas!=TT)
                puts("");
        }
    
    return 0;
}