BZOJ1089: [SCOI2003]严格n元树

1089: [SCOI2003]严格n元树

Time Limit: 1 Sec  Memory Limit: 162 MB
Submit: 762  Solved: 387
[Submit][Status]

Description

如果一棵树的所有非叶节点都恰好有n个儿子，那么我们称它为严格n元树。如果该树中最底层的节点深度为d（根的深度为0），那么我们称它为一棵深度为d的严格n元树。例如，深度为２的严格２元树有三个，如下图：

给出n, d，编程数出深度为d的n元树数目。

Input

仅包含两个整数n, d( 0   <   n   <   =   32,   0  < =   d  < = 16)

Output

仅包含一个数，即深度为d的n元树的数目。

Sample Input

【样例输入1】
2 2

【样例输入2】
2 3

【样例输入3】
3 5

Sample Output

【样例输出1】
3

【样例输出2】
21

【样例输出2】
58871587162270592645034001

HINT

Source

题解：

先说一下此题我的想法（尽管没有A掉。。。）

考虑递推解此题：

设f[i]表示深度为i的严格n元树的数目，g[i]表示深度为（1--i）的严格n元树的数目。

则我们有如下递推式：

1.f[i]=g[i-1]^n-g[i-2]^n

2.g[i]=g[i-1]+f[i]

第二个是显然的，我们来说一下第一个是怎么来的。

因为我们从i-1递推到i，所以考率在n棵子树上加一个根节点，其余为原先的子树

因为要保证这棵树的深度达到n，所以至少有一个子树的深度达到n-1，

所以每个子树可以有g[i-1]种形态，n棵就是g[i-1]^n，然后去掉不合法的，

不合法的就是每个子树的深度都在1--i-2，即有g[i-2]种选择，也就是 g[i-2]^n

然后如果我们使用累加法的话可以发现 g[i]=g[i-1]^n+1，貌似很简单了？

TLE！！！尽管没有试，但我想是这样的，因为这个复杂度的话，ans必须<=4000位，看起来貌似不可能那么少。。。

高精度乘高精度太浪费时间了，我暂时没有想到好的解决办法。

贴一下上面的代码（没有用累加法）

#include<cstdio>

#include<cstdlib>

#include<cmath>

#include<cstring>

#include<algorithm>

#include<iostream>

#include<vector>

#include<map>

#include<set>

#include<queue>

#include<string>

#define inf 1000000000

#define maxn 50

#define maxm 500000

#define eps 1e-10

#define ll long long

#define pa pair<int,int>

#define for0(i,n) for(int i=0;i<=(n);i++)

#define for1(i,n) for(int i=1;i<=(n);i++)

#define for2(i,x,y) for(int i=(x);i<=(y);i++)

#define for3(i,x,y) for(int i=(x);i>=(y);i--)

#define mod 10000

using namespace std;

inline int read()

{

    int x=0,f=1;char ch=getchar();

    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}

    while(ch>='0'&&ch<='9'){x=10*x+ch-'0';ch=getchar();}

    return x*f;

}
int n,m,f[maxn][maxm],g[2][maxm],t[maxm],c[maxm];
inline void writeln(int *a)
{
    cout<<a[a[0]];
    for3(i,a[0]-1,1)cout<<a[i];cout<<endl;
}
inline void update(int *a)
{
    for1(i,a[0])
    {
        a[i+1]+=a[i]/mod;
        a[i]%=mod;
        if(a[a[0]+1])a[0]++;
    }
}
inline void mul(int *a,int x)
{
    for1(i,a[0])a[i]*=x;
    update(a);
}
inline void jia(int *a,int *b)
{
    a[0]=max(a[0],b[0]);
    for1(i,a[0])
     {
         a[i]+=b[i];
         a[i+1]+=a[i]/mod;
         a[i]%=mod;
     }
    while(!a[a[0]])a[0]--; 
}
inline void cheng(int *a,int *b)
{
    memset(c,0,sizeof(c));
    for1(i,a[0])
     for1(j,b[0])
      {
       c[i+j-1]+=a[i]*b[j];
       c[i+j]+=c[i+j-1]/mod;
       c[i+j-1]%=mod;
      }
    c[0]=a[0]+b[0]+1;  
    while(!c[c[0]]&&c[0])c[0]--;
    memcpy(a,c,sizeof(c));    
}
inline void jian(int *a,int *b)
{
    for1(i,a[0])
     {
       a[i]-=b[i];
       if(a[i]<0)a[i]+=mod,a[i+1]-=1;
     }
    while(!a[a[0]])a[0]--; 
}

int main()

{

    freopen("input.txt","r",stdin);

    freopen("output.txt","w",stdout);

    n=read();m=read();
    f[1][f[1][0]=1]=1;
    g[0][g[0][0]=1]=1;
    g[1][g[1][0]=1]=2;
    for2(i,2,m)
    {
        f[i][f[i][0]=1]=1;
        for1(j,n)cheng(f[i],g[1]);
        t[t[0]=1]=1;
        for1(j,n)cheng(t,g[0]);
        jian(f[i],t);
        jia(g[0],f[i-1]);
        jia(g[1],f[i]);
    }
    printf("%d",f[m][f[m][0]]);
    for3(i,f[m][0]-1,1)printf("%04d",f[m][i]);

    return 0;

}

 感觉不会再爱了，这居然就是正解QAQ

不会貌似别人解释的更简单，直接推g[i]的表达式也很简单。

妈蛋，数据范围给的太大了，和lydsy要过来数据发现全是非常小的T_T

我做了2天多，一直在对拍自己的程序为什么出错，AC的程序运行过程中答案为什么会越来越小，我的程序为什么10 15的点都跑不出来，而且位数剧增

今天才发现是别人的空间爆了啊。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

还以为是我的程序错了啊。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

看来我的推断没有错，如果数据范围真如题中所说，那么答案的位数就太大了。

我要去建议lydsy修改此题的题面，不要再像坑我一样坑了其他人。。。

 代码：

#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<string>
#define inf 1000000000
#define maxn 500+100
#define maxm 500+100
#define eps 1e-10
#define ll long long
#define pa pair<int,int>
#define for0(i,n) for(int i=0;i<=(n);i++)
#define for1(i,n) for(int i=1;i<=(n);i++)
#define for2(i,x,y) for(int i=(x);i<=(y);i++)
#define for3(i,x,y) for(int i=(x);i>=(y);i--)
#define mod 10000
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=10*x+ch-'0';ch=getchar();}
    return x*f;
}
class bigg
{
public:
    int num[maxn], len;
    bigg()
    {
        memset(num,0,sizeof(num));
        len=0;
    }
    bigg operator = (const bigg &b)
    {
        memset(num,0,sizeof(num));
        len=b.len;
        for1(i,len)num[i]=b.num[i];
        return(*this);
    }
    bigg operator = (int b)
    {
        memset(num,0,sizeof(0));
        if (b==0)
        {
            len=1;
            return(*this);
        }
        len=0;
        while(b>0)
        {
            num[++len]=b%mod;
            b/=mod;
        }
        return (*this);
    }
    bigg operator * (const bigg &b)
    {
        bigg ans;
        ans=0;
        if (len==1&&num[1]==0||b.len==1&&b.num[1]==0)
            return ans;
        ans.len=len+b.len-1;
        for1(i,len)
        for1(j,b.len)
        {
            ans.num[i+j-1]+=num[i]*b.num[j];
            ans.num[i+j]+=ans.num[i+j-1]/mod;
            ans.num[i+j-1]%=mod;
        }
        if (ans.num[ans.len+1])ans.len++;
        while(!ans.num[ans.len])ans.len--;
        return ans;
    }
    bigg operator - (const bigg &b)
    {
        bigg ans;
        ans=0;
        ans.len=len;
        for1(i,len)
        {
            ans.num[i]+=num[i]-b.num[i];
            if (ans.num[i]<0)
            {
                ans.num[i+1]--;
                ans.num[i]+=mod;
            }
        }
        while (ans.len>1&&!ans.num[ans.len]) ans.len--;
        return ans;
    }
    bigg operator + (const bigg &b)
    {
        bigg ans;
        ans=0;
        ans.len=max(len,b.len);
        for1(i,ans.len)
        {
            ans.num[i]+=num[i]+b.num[i];
            ans.num[i+1]=ans.num[i]/mod;
            ans.num[i]%=mod;
        }
        if (ans.num[ans.len+1])ans.len++;
        return ans;
    }
    void print()
    {
        printf("%d",num[len]);
        for3(i,len-1,1)printf("%04d",num[i]);
        printf("
");
    }
};
 
int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    int n, deep;
    scanf("%d%d", &n, &deep);
    if (deep == 0) 
    {
        printf("1
");
        return 0;
    }
    bigg fpre, fnow, f1;
    fpre=1,f1=1;
    for1(i,deep)
    {
        fnow=1;
        for1(j,n)fnow=fnow*fpre;   
        fnow=fnow+f1;
        if (i!= deep) fpre=fnow;
    }
    fnow=fnow-fpre;
    fnow.print();
    return 0;
}
    

不过还是有几点收获的：

1.捞到一个高精度模版

2.class里数组要开小