高中OJ3874. 【NOIP2014八校联考第4场第2试10.20】准备复赛(exam)

题目描述

Description
今年的NOIP初赛真是简单，小可可不用吹灰之力就考进了复赛，但是复赛可没有那么简单了，小可可想要好好准备复赛，争取复赛拿个省一。今天小可可在复习树和图的最大匹配时就碰到这样的一个难题：n个节点满足以下性质的不同的树有多少种。
1、树是有标号的，每个节点被标上1到n之间的整数；
2、每个节点最多和其他3个节点相连，但是1号节点最多和其他2个节点相连；
3、这棵树的最大匹配（把树看成二分图后的最大匹配）数为k。
两棵树被认为不同当且仅当存在两个点u、v，在一棵树中u、v之间有边，另一棵树中u、v之间没边。
由于答案可能很大，所以小可可让你输出答案模1000000007 (10^9 + 7)。

Input
第一行包含两个正整数n，k。
Output
包含一行，为方案数。

Sample Input
4 2
Sample Output
12

Data Constraint
对于30%的数据，2≤n≤5；
对于60%的数据，2≤n≤20；
对于100%的数据，2≤n≤50。

正解

设$F[i,j]$表示子数节点个数为i，最大匹配为j，且根节点被匹配。
设$G[i,j]$表示子数节点个数为i，最大匹配为j，且根节点未被匹配。

一颗子树

则$F[i,j]=G[i-1,j-1]*i$（当前根节点被匹配，说明子树之前一定未被匹配）
$G[i,j]=F[i-1,j]*i$（当前根节点未被匹配，说明子树之前一定被匹配）

至于为什么要*i，因为我们无法得知子树内节点的具体大小，所以只能在原来的(i-1)个节点中的i个空隙中插入一个新节点。

两颗子树

如果根节点未被匹配，说明两个子树的根节点一定被匹配。
如果根节点被匹配，则两个子树的根节点一定有一个未被匹配。

方程自推。
因为有可能两个子树根节点的状态相同，所以有可能会枚举两次，所以要保证左子树的节点数小于等于右子树的节点数。
当然如果两个子树的节点数量相同，也要/2。

因为题目要求不同的树定义为连边不同，所以还要算C(x1+x2,x1)，算出两个子树一共有多少种情况。

题目要求最后的根节点一定是1，所以最后答案要/n。

code

#include <cstdio>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
#define mod 1000000007
#define min(x,y) (x)<(y)?(x):(y)
using namespace std;
long long i,j,k1,l1,k2,l2;
long long f[51][26];
long long g[51][26];
long long p[51];
long long ny[51];
long long c[51][51];
long long n,m;

long long mi(long long a)
{
    long long sum,t;

    a%=mod;
    t=mod-2;
    sum=1;

    while (t)
    {
        if (t&1)
        {
            sum=sum*a%mod;
        }

        a=a*a%mod;

        t>>=1;
    }

    return sum;
}

long long C(int n,int m)
{
    return (p[n]*ny[m]%mod*ny[n-m]%mod);
}

int main()
{
    scanf("%d%d",&n,&m);

    if ((m*2)>n)
    {
        printf("0");
        return 0;
    }

    p[1]=1;
    ny[1]=1;
    fo(i,2,n)
    p[i]=p[i-1]*i%mod,ny[i]=mi(p[i]);

    fo(i,1,n)
    {
        fo(j,1,i)
        c[i][j]=C(i,j);
    }

    g[1][0]=1;
    fo(i,2,n)
    {
        fo(j,0,(min((i+1)>>1,m)))
        {
            if (j)
            f[i][j]=g[i-1][j-1]*i%mod;
            g[i][j]=f[i-1][j]*i%mod;

            fo(l1,0,j)
            {
                l2=j-l1;

                fo(k1,1,(i-1)>>1)
                {
                    k2=i-k1-1;

                    if ((f[k1][l1]) && (f[k2][l2]))
                    if (k1!=k2)
                    g[i][j]=(g[i][j]+(i*f[k1][l1]%mod)*f[k2][l2]%mod*c[i-1][k1])%mod;
                    else
                    g[i][j]=(g[i][j]+(i*f[k1][l1]%mod)*f[k2][l2]%mod*c[i-1][k1]%mod*500000004)%mod;

                    if (g[k1][l1])
                    {
                        if (l2)
                        {
                            if (k1!=k2)
                            f[i][j]=(f[i][j]+(i*g[k1][l1]%mod)*g[k2][l2-1]%mod*c[i-1][k1])%mod;
                            else
                            f[i][j]=(f[i][j]+(i*g[k1][l1]%mod)*g[k2][l2-1]%mod*c[i-1][k1]%mod*500000004)%mod;

                            if (f[k2][l2-1])
                            f[i][j]=(f[i][j]+(i*g[k1][l1]%mod)*f[k2][l2-1]%mod*c[i-1][k1])%mod;
                        }
                    }
                }

                if (l2)
                fo(k1,((i-1)>>1)+1,i-2)
                {
                    k2=i-k1-1;

                    if ((g[k1][l1]) && (f[k2][l2-1]))
                    f[i][j]=(f[i][j]+(i*g[k1][l1]%mod)*f[k2][l2-1]%mod*c[i-1][k1])%mod;
                }
            }
        }
    }

    printf("%lld\n",(f[n][m]+g[n][m])*mi(n)%mod);
}