CF1111E Tree 动态规划+LCT

这个题的思路非常好啊.

我们可以把 $k$ 个点拿出来，那么就是求将 $k$ 个点划分成不大于 $m$ 个集合的方案数.

令 $f[i][j]$ 表示将前 $i$ 个点划分到 $j$ 个集合中的方案数.

那么有 $f[i][j]=f[i-1][j-1]+f[i-1][j]*(j-fail[i])$，其中 $fail[i]$ 代表 $i$ 到根这条路径上祖先数量.

而 $fail[i]$ 的求解方式有：虚数统计/树上数据结构维护路径和，这里选择了用 LCT 来维护.

code:

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
#define N 100007
#define ll long long
#define mod 1000000007
#define setIO(s) freopen(s".in","r",stdin)
using namespace std;
namespace LCT
{
    #define lson t[x].ch[0]
    #define rson t[x].ch[1]
    struct node
    {
        int ch[2],f,rev,sum,val;
    }t[N];
    int sta[N];
    int get(int x)
    {
        return t[t[x].f].ch[1]==x;
    }
    int isrt(int x)
    {
        return !(t[t[x].f].ch[0]==x||t[t[x].f].ch[1]==x);
    }
    void pushup(int x)
    {
        t[x].sum=t[lson].sum+t[rson].sum+t[x].val;
    }
    void mark(int x)
    {
        t[x].rev^=1;
        swap(lson,rson);
    }
    void pushdown(int x)
    {
        if(t[x].rev)
        {
            if(lson) mark(lson);
            if(rson) mark(rson);
            t[x].rev=0;
        }
    }
    void rotate(int x)
    {
        int old=t[x].f,fold=t[old].f,which=get(x);
        if(!isrt(old)) t[fold].ch[t[fold].ch[1]==old]=x;
        t[old].ch[which]=t[x].ch[which^1],t[t[old].ch[which]].f=old;
        t[x].ch[which^1]=old,t[old].f=x,t[x].f=fold;
        pushup(old),pushup(x);
    }
    void splay(int x)
    {
        int v=0,u=x,fa;
        for(sta[++v]=u;!isrt(u);u=t[u].f) sta[++v]=t[u].f;
        for(;v;--v) pushdown(sta[v]);
        for(u=t[u].f;(fa=t[x].f)!=u;rotate(x))
        {
            if(t[fa].f!=u)
                rotate(get(fa)==get(x)?fa:x);
        }
    }
    void Access(int x)
    {
        for(int y=0;x;y=x,x=t[x].f)
        {
            splay(x);
            rson=y;
            pushup(x);
        }
    }
    void makeroot(int x)
    {
        Access(x),splay(x),mark(x);
    }
    void split(int x,int y)
    {
        makeroot(x),Access(y),splay(y);
    }
    void add(int x,int v)
    {
        Access(x),splay(x);
        t[x].val+=v,pushup(x);
    }
    int query(int x)
    {
        Access(x),splay(x);
        return t[x].sum;
    }
    #undef lson
    #undef rson
};
int n,edges;
int hd[N],to[N<<1],nex[N<<1],f[N],A[N],dp[N][302];
void add(int u,int v)
{
    nex[++edges]=hd[u],hd[u]=edges,to[edges]=v;
}
void dfs(int u,int ff)
{
    LCT::t[u].f=ff;
    for(int i=hd[u];i;i=nex[i])
    {
        int v=to[i];
        if(v==ff) continue;
        dfs(v,u);
    }
}
int main()
{
    // setIO("input");
    int i,j,q;
    scanf("%d%d",&n,&q);
    for(i=1;i<n;++i)
    {
        int x,y;
        scanf("%d%d",&x,&y);
        add(x,y),add(y,x);
    }
    dfs(1,0);
    for(i=1;i<=q;++i)
    {
        int k,m,r,flag=0;
        scanf("%d%d%d",&k,&m,&r);
        LCT::makeroot(r);
        for(j=1;j<=k;++j)
        {
            scanf("%d",&A[j]);
            LCT::add(A[j],1);
        }
        for(j=1;j<=k;++j)
        {
            f[j]=LCT::query(A[j])-1;
            if(f[j]>m) flag=1;
        }
        for(j=1;j<=k;++j)  LCT::add(A[j],-1);
        if(flag)   printf("0\n");
        else
        {
            sort(f+1,f+1+k);
            dp[1][1]=1;
            for(j=2;j<=k;++j)
            {
                for(int p=1;p<=min(j,m);++p)
                {
                    dp[j][p]=0;
                    if(p<f[j])   dp[j][p]=dp[j-1][p-1];
                    else dp[j][p]=(ll)(dp[j-1][p-1]+1ll*(p-f[j])*dp[j-1][p]%mod)%mod;
                }
            }
            int ans=0;
            for(j=1;j<=m;++j)  ans=(ans+dp[k][j])%mod;
            printf("%d\n",ans);
        }
    }
    return 0;
}