UVALive 7148 LRIP【树分治+线段树】

　　题意就是要求一棵树上的最长不下降序列，同时不下降序列的最小值与最大值不超过D。

　　做法是树分治+线段树，假设树根是x,y是其当前需要处理的子树，对于子树y，需要处理出两个数组MN,MX，MN[i]表示以x为第一个数字的不下降子序列中第i个数的最小值，MX[i]表示以x为第一个数字的不上升子序列中第i个数的最大值。如果当前子树有一个以x为首的不下降序列，那么我们就需要在之前处理的子树中找一条以x为首的满足约束条件不上升序列，可以用线段树来查询。同时每做完一颗子树的时候，用MN,MX对线段树进行更新。对于不经过x的情况可以递归下去处理。

　　代码:

#include<cstdio>
#include<algorithm>
#include<cstring>
#define N 1000010
using namespace std;
int dp,p[N],s[N],pre[N],tt[N],flag[N],father[N],tmproot,n,d,ttt;
int i,v[N],a,b,mn,mx,MN[N],MX[N],U,V,ans;
int l[N],r[N],smn[N],smx[N],vsmn[N],vsmx[N];
void build(int x,int a,int b)
{
    int m;
    l[x]=a;r[x]=b;
    if (x>ttt) ttt=x;
    if (b-a>1)
    {
        m=(a+b)>>1;
        build(2*x,a,m);
        build(2*x+1,m,b);
    }
}
void clean(int x)
{
    if (vsmn[x])
    {
        smn[x]=0;
        if (2*x<=ttt)
        vsmn[2*x]=1;
        if (2*x+1<=ttt)
        vsmn[2*x+1]=1;
        vsmn[x]=0;
    }
    
    if (vsmx[x])
    {
        smx[x]=0;
        if (2*x<=ttt)
        vsmx[2*x]=1;
        if (2*x+1<=ttt)
        vsmx[2*x+1]=1;
        vsmx[x]=0;
    }
}
void change(int x,int a,int b,int c,int typ)
{
    int m;
    clean(x);
    if ((a<=l[x])&&(r[x]<=b))
    {
        if (typ==0)
        smn[x]=max(smn[x],c);
        else
        smx[x]=max(smx[x],c);
        return;
    }
    m=(l[x]+r[x])>>1;
    if (a<m) change(2*x,a,b,c,typ);
    if (m<b) change(2*x+1,a,b,c,typ);
    clean(2*x);clean(2*x+1);
    if (!typ)
    smn[x]=max(smn[2*x],smn[2*x+1]);
    else
    smx[x]=max(smx[2*x],smx[2*x+1]);
}
int query(int x,int a,int b,int typ)
{
    int m,ans=0;
    clean(x);
    if ((a<=l[x]&&(r[x]<=b)))
    {
        if (typ==0)
        return smn[x];
        else
        return smx[x];
    }
    m=(l[x]+r[x])>>1;
    if (a<m) ans=max(ans,query(2*x,a,b,typ));
    if (m<b) ans=max(ans,query(2*x+1,a,b,typ));
    return ans;
} 
void link(int x,int y)
{
    dp++;pre[dp]=p[x];p[x]=dp;tt[dp]=y;
}
int getroot(int x,int fa,int sum)
{
    int i,f=0;
    i=p[x];
    father[x]=fa;
    s[x]=1;
    while (i)
    {
        if ((tt[i]!=fa)&&(!flag[tt[i]]))
        {
            getroot(tt[i],x,sum);
            s[x]=s[x]+s[tt[i]];
            if (s[tt[i]]>sum/2) f=1;
        }
        i=pre[i];
    }
    if (sum-s[x]>sum/2) f=1;
    if (!f) tmproot=x;
}
void dfs(int x,int fa,int mn,int mx)
{
    int i;
    i=p[x];
    if (v[x]>=v[fa])
    {
        if (mn) 
        {
            mn++;
            MN[mn]=min(MN[mn],v[x]);
        }
        if (v[x]>v[fa])
        mx=0;
    }
    if (v[x]<=v[fa])
    {
        if (mx) 
        {
            mx++;
            MX[mx]=max(MX[mx],v[x]);
        }
        if (v[x]<v[fa])
        mn=0;
    }
    U=max(U,mn);
    V=max(V,mx);
    while (i)
    {
        if ((tt[i]!=fa)&&(!flag[tt[i]]))
            dfs(tt[i],x,mn,mx);
        i=pre[i];
    }
}
void work(int x,int sum)
{
    int i,j,k,root;
    getroot(x,0,sum);
    root=tmproot;
    i=p[root];
    flag[root]=1;
    while (i)
    {
        if (flag[tt[i]]==0)
        {
            if (tt[i]==father[root])
            work(tt[i],sum-s[root]);
            else
            work(tt[i],s[tt[i]]);
        }
        i=pre[i];
    }
//------------------------------
    i=p[root];
    vsmn[1]=1;
    vsmx[1]=1;
    while (i)
    {
        if (!flag[tt[i]])
        {
            for (j=2;j<=U;j++)
            MN[j]=0x37373737;
            for (j=2;j<=V;j++)
            MX[j]=0;
            U=0;V=0;
            dfs(tt[i],root,1,1);
            for (j=2;j<=U;j++)
            {    
                if (MN[j]-d<=v[root])
                ans=max(ans,j);
                k=MN[j]-d;
                if (k<1) k=1;
                if (k<=v[root])
                ans=max(ans,j+query(1,k-1,v[root],1)-1);
            }
            for (j=2;j<=V;j++)
            {
                if (MX[j]+d>=v[root])
                ans=max(ans,j);
                k=MX[j]+d;
                if (k>100000) k=100000;
                if (k>=v[root])
                ans=max(ans,j+query(1,v[root]-1,k,0)-1);
            }
            
            
            for (j=2;j<=U;j++)
            change(1,MN[j]-1,MN[j],j,0);
            for (j=2;j<=V;j++)
            change(1,MX[j]-1,MX[j],j,1);
        }
        i=pre[i];
    }
    flag[root]=0;
}
int main()
{
    build(1,0,100000);
    for (i=0;i<=100000;i++)
    MN[i]=0x37373737;
    int test,ii=0;
    scanf("%d",&test);
    while (test)
    {
    test--;
    ii++;
    dp=0;memset(p,0,sizeof(p));
    scanf("%d%d",&n,&d);
    for (i=1;i<=n;i++)
    scanf("%d",&v[i]);
    for (i=1;i<=n-1;i++)
    {
        scanf("%d%d",&a,&b);
        link(a,b);
        link(b,a);
    }
    ans=1;
    work(1,n);
    printf("Case #%d: %d
",ii,ans);
    }
}