POJ 4005 笛卡尔树+线段树+KMP

题意：
给出n个鼹鼠的编号（打乱顺序）排成一列，从第一个（非编号）鼹鼠开始挖洞，第2-n个鼹鼠在第一个鼹鼠挖洞的基础上挖洞，如果编号比之前的大就往右边走，否则往左边走，如果走不通（即左边或者右边没有洞），就自己挖洞，每只鼹鼠都会挖恰好一个洞。最终会形成一个二叉搜索树，得到这个树的dfs序列，把每一项都%2，最终得到一个01序列，与输入序列匹配，求输入序列在dfs序列中出现过多少次。

（貌似说的不太清楚，看不懂的话可以去读原题，很容易看懂，我这英语水平都读懂了。。。就是表达不出来）

思路：

笛卡尔树，鼹鼠的排列顺序满足小根堆的性质，编号满足二叉搜索树的顺序，就可以构造了~

最后kmp就可以了~

PS：

dfs和建树必须是非递归的，递归会暴栈（想想60万层）

rmq其实更好，只不过我没能开下。就写了线段树

笛卡尔树可以有O(n)的建树方法（除去排序），也非常简短，但是我不会。。。

吐槽：

这题递归三行改成非递归就成60行了。。。

G++ wa，c++在poj2900ms卡时过，在hdu 4125   1800ms过

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

#define N 750010

using namespace std;

struct PO
{
    int a,w;
}po[N];

struct TR
{
    int u,l,r;
}tr[N];

struct Q
{
    int bh,l,r;
}q[N],wc;

struct QQ
{
    int bh,pd;
}qq[N],we;

int s[N],p,pos,n,cnt,tt,next[N],b[N],len,mx[N*2];

char str[N];

inline bool cmp(const PO &a,const PO &b)
{
    return a.a<b.a;
}

inline int jmin(int x,int y)
{
    if(po[x].w<po[y].w) return x;
    return y;
}

void build(int u,int l,int r)
{
    if(l==r) {mx[u]=l;return;}
    int mid=(l+r)>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    mx[u]=jmin(mx[u<<1],mx[u<<1|1]);
}

void query(int u,int L,int R,int l,int r)
{
    if(L<=l&&r<=R) {pos=jmin(pos,mx[u]);return;}
    int mid=(l+r)>>1;
    if(L<=mid) query(u<<1,L,R,l,mid);
    if(R>mid) query(u<<1|1,L,R,mid+1,r);
}

void read()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&po[i].a);
        po[i].w=i;
    }
    po[0].w=0x7f7f7f7f;
    sort(po+1,po+1+n,cmp);
    build(1,1,n);
}

void create()
{
    cnt=1;
    int size=1;
    q[size].bh=1; q[size].l=1; q[size].r=n;
    while(size)
    {
        wc=q[size--];
        pos=0;
        query(1,wc.l,wc.r,1,n);
        tr[wc.bh].u=po[pos].a;
        if(wc.l<=pos-1)
        {
            tr[wc.bh].l=++cnt;
            q[++size].bh=cnt;
            q[size].l=wc.l;
            q[size].r=pos-1;
        }
        if(wc.r>=pos+1)
        {
            tr[wc.bh].r=++cnt;
            q[++size].bh=cnt;
            q[size].l=pos+1;
            q[size].r=wc.r;
        }
    }
}

void dfs()
{
    int size=1;
    qq[size].bh=1; qq[size].pd=0;
    while(size)
    {
        we=qq[size];
        if(we.pd==0)
        {
            s[++p]=tr[we.bh].u&1;
            if(tr[we.bh].l!=-1)
            {
                qq[size].pd=1;
                qq[++size].bh=tr[we.bh].l;
                qq[size].pd=0;
                continue;
            }
            if(tr[we.bh].r!=-1)
            {
                qq[size].pd=2;
                qq[++size].bh=tr[we.bh].r;
                qq[size].pd=0;
                continue;
            }
        }
        if(we.pd==1)
        {
            s[++p]=tr[we.bh].u&1;
            if(tr[we.bh].r!=-1)
            {
                qq[size].pd=2;
                qq[++size].bh=tr[we.bh].r;
                qq[size].pd=0;
                continue;
            }
        }
        if(we.pd==2) s[++p]=tr[we.bh].u&1; 
        size--;
    }
}

void getnext()
{
    next[1]=0;
    int i,j=0;
    for(i=2;i<=len;i++)
    {
        while(j>0&&b[j+1]!=b[i]) j=next[j];
        if(b[j+1]==b[i]) j+=1;
        next[i]=j;
    }
}

int kmp()
{
    int i,j=0,num=0;
    for(i=1;i<=p;i++)
    {
        while(j>0&&b[j+1]!=s[i]) j=next[j];
        if(b[j+1]==s[i]) j+=1;
        if(j==len)
        {
            num++;
            j=next[j];
        }
    }
    return num;
}

void go()
{
    memset(tr,-1,sizeof tr);
    create();
    p=0;
    dfs();
    scanf("%s",str+1);
    len=strlen(str+1);
    for(int i=1;i<=len;i++) b[i]=str[i]-'0';
    getnext();
    printf("%d\n",kmp());
}

int main()
{
    scanf("%d",&tt);
    for(int i=1;i<=tt;i++)
    {
        read();
        printf("Case #%d: ",i);
        go();
    }
    //system("pause");
    return 0;
}