[AHOI2012]树屋阶梯

问题 E: [AHOI2012]树屋阶梯

时间限制: 1 Sec  内存限制: 128 MB

题目描述

暑假期间，小龙报名了一个模拟野外生存作战训练班来锻炼体魄，训练的第一个晚上，教官就给他们出了个难题。由于地上露营湿气重，必须选择在高处的树屋露营。小龙分配的树屋建立在一颗高度为N+1尺（N为正整数）的大树上，正当他发愁怎么爬上去的时候，发现旁边堆满了一些空心四方钢材（如图1.1），经过观察和测量，这些钢材截面的宽和高大小不一，但都是1尺的整数倍，教官命令队员们每人选取N个空心钢材来搭建一个总高度为N尺的阶梯来进入树屋，该阶梯每一步台阶的高度为1尺，宽度也为1尺。如果这些钢材有各种尺寸，且每种尺寸数量充足，那么小龙可以有多少种搭建方法？（注：为了避免夜里踏空，钢材空心的一面绝对不可以向上。）

   以树屋高度为4尺、阶梯高度N=3尺为例，小龙一共有如图1.2所示的5种

   搭 建方法：

   

输入

一个正整数 N(1≤N≤500)，表示阶梯的高度

输出

一个正整数，表示搭建方法的个数。（注：搭建方法个数可能很大。）

样例输入

3

样例输出

5

提示

1  ≤N≤500

solution：

　　　这题明显卡特兰数，然而我还傻傻的打了个暴搜去找规律，数论真是个大坑。不过需要高精度，于是把高精度这个坑补了一下，code上自带高精的各种运算。

　　　　

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
#define M 10
#define P 1
__attribute__((optimize("O3")))int read() {
    int s=0,f=1;
    char ch=getchar();
    for(; ch<'0'||ch>'9'; ch=getchar()) {
        if(ch=='-') {
            f=-1;
        }
    }
    for(; ch>='0'&&ch<='9'; ch=getchar()) {
        s=(s<<1)+(s<<3)+(ch^48);
    }
    return s*f;
}
struct BigNum {
    int n[5000],l,Y;
    BigNum() {
        l=1,memset(n,0,sizeof(n));
    }
    //----------------------------------
    __attribute__((optimize("O3")))void init() {
        string s;
        cin>>s;
        int now=0,ct=0,c1=1;
        for(int i=s.length()-1; i>=0; i--) {
            n[now]+=(s[i]-'0')*c1;
            c1*=10;
            ct++;
            if(ct==P&&i!=0) {
                now++;
                c1=1;
                ct=0;
            }
        }
        l=now+1;
    }
    //-----------------------------------
    __attribute__((optimize("O3")))void print() {
        printf("%d",n[l-1]);
        for(int i=l-2; i>=0; i--)
            printf("%0*d",P,n[i]);
        printf("\n");
    }
    //------------------------------------
    BigNum operator +(BigNum x)const {
        BigNum t=*this;
        if(x.l>t.l)t.l=x.l;
        for(int i=0; i<t.l; i++) {
            t.n[i]+=x.n[i];
            if(t.n[i]>=M) {
                t.n[i+1]+=t.n[i]/M;
                t.n[i]%=M;
            }
        }
        while(t.n[t.l]) {
            t.n[t.l+1]+=t.n[t.l]/M;
            t.n[t.l++]%=M;
        }
        return t;
    }
    //--------------------------------------
    __attribute__((optimize("O3")))bool operator < (BigNum x) const {
        BigNum t=*this;
        if(t.l!=x.l)return t.l<x.l;
        for(int i=t.l-1; i>=0; i--) {
            if(t.n[i]!=x.n[i])return t.n[i]<x.n[i];
        }
        return 0;
    }
    BigNum operator -(BigNum x)const {
        BigNum t=*this;
        if(t<x) {
            printf("-");
            swap(t,x);
        }
        for(int i=0; i<t.l; i++) {
            t.n[i]-=x.n[i];
            if(t.n[i]<0) {
                t.n[i]+=M;
                --t.n[i+1];
            }
        }
        while(!t.n[t.l-1]&&t.l>1)t.l--;
        return t;
    }
    //--------------------------------------------
    BigNum operator * (BigNum x) const {
        BigNum c,t=*this;
        c.l=t.l+x.l-1;
        for(int i=0; i<t.l; i++)
            for(int j=0; j<x.l; j++) {
                c.n[i+j]+=t.n[i]*x.n[j];
                if(c.n[i+j]>=M) {
                    c.n[i+j+1]+=c.n[i+j]/M;
                    c.n[i+j]%=M;
                }
            }
        while(c.n[c.l]) {
            c.n[c.l+1]+=c.n[c.l]/M;
            c.n[c.l++]%=M;
        }
        return c;
    }
    BigNum operator * (int x) const {
        BigNum t=*this,c;
        c.l=t.l;
        for(int i=0; i<t.l; i++) {
            c.n[i]+=t.n[i]*x;
            if(c.n[i]>=M) {
                c.n[i+1]+=c.n[i]/M;
                c.n[i]%=M;
            }
        }
        while(c.n[c.l]) {
            c.n[c.l+1]+=c.n[c.l]/M;
            c.n[c.l++]%=M;
        }
        return c;
    }
    //--------------------------------------------
    __attribute__((optimize("O3")))void Add(int x) {
        if(x||l)n[l++]=x;
    }
    __attribute__((optimize("O3")))void Re() {
        reverse(n,n+l);
    }
    BigNum operator /(const BigNum &x)const {
        BigNum t=*this,r,y;
        y.l=0,r.l=t.l;
        for(int i=t.l-1; i>=0; --i) {
            y.Add(t.n[i]);
            y.Re();
            while(!(y<x))y=y-x,r.n[i]++;
            while(!y.n[y.l-1] && y.l>1)--y.l;
            y.Re();
        }
        while(!r.n[r.l-1] && r.l>1)--r.l;
        return r;
    }
    BigNum operator /(const int &x)const {
        BigNum t=*this,r;
        r.l=t.l;
        int tmp=0;
        for(int i=t.l-1; i>=0; --i) {
            tmp+=t.n[i];
            if(tmp>=x)
                r.n[i]+=tmp/x,tmp%=x;
            tmp*=M;
        }
        while(!r.n[r.l-1] && r.l>1)--r.l;
        return r;
    }
    //---------------------------------------

} ans;
int n;
int main() {
    n=read();
    ans.l=1;
    ans.n[0]=1;
    for(int i=2*n;i>n;--i){
        ans=ans*i;
    }
    for(int i=2;i<=n;++i){
        ans=ans/i;
    }
    ans=ans/(n+1);
    ans.print();
    return 0;
}