[AHOI2012]树屋阶梯

同步:http://buringstraw.win/index.php/archives/17/

题目

输入格式:

一个正整数N(1<=N<=500),表示阶梯的高度。

输出格式:

一个正整数,表示搭建方法的个数。(注:搭建方法的个数可能很大)

分析

通过人肉打表找规律严格证明发现这是个卡特兰数

然后要求到第500项#(喷)

所以这同时也是个优秀的高精度板子

Code

首先是高精度部分(两个板子的codemix)

struct bigNum{
    private:
        short t[1005];int siz;

    public:
        bigNum(string a){
            memset(t,0,sizeof(t));
            int len=a.size();
            for(int i=0;i<a.size();++i){
                t[len-i]=a[i];
            }
            siz=len;
        }

        bigNum(void){
            memset(t,0,sizeof(t));
            siz=0;
        }

        bigNum(long long x){
            memset(t,0,sizeof(t));
            int ws=0;
            while(x){
                ++ws;
                int q=x%10;
                x/=10;
                t[ws]=q;
            }
            siz=ws;
        }

        void print(void){
            for(int i=siz;i>=1;--i){
                putchar(t[i]+'0');
            }
            putchar('\n');
        }

        int size(void){
            return siz;
        }

        friend bigNum operator *(bigNum a,long long b){
            bigNum c;
            int len=a.size()+20,g=0;
            for(int i=1;i<=len;++i){
                c.t[i]=a.t[i]*b;
            }
            for(int i=1;i<=len;++i){
                if(c.t[i]>9){
                    c.t[i+1]+=c.t[i]/10;
                    c.t[i]=c.t[i]%10;
                }
            }
            while(len>1&&c.t[len]==0)--len;
            c.siz=len;
            return c;
        }

        friend bigNum operator *(long long b,bigNum a){
            return a*b;
        }

        friend bigNum operator *(bigNum a,bigNum b){
            bigNum c;
            int len=a.size()+b.size();
            for(int i=1;i<=a.size();++i){
                for(int j=1;j<=b.size();++j){
                    c.t[i+j-1]+=(a.t[i]*b.t[j]);
                }
            }

            for(int i=1;i<=len;++i){
                if(c.t[i]>9){
                    c.t[i+1]+=c.t[i]/10;
                    c.t[i]=c.t[i]%10;
                }
            }
            while(len>1 && c.t[len]==0)len--;
            c.siz=len;
            return c;
        }

        friend bigNum operator /(bigNum a,long long b){
            bigNum c;
            int k=a.size(),g=0;
            for(int i=k;i>0;--i){
                g=g*10+a.t[i];
                c.t[i]=g/b;
                g%=b;
            }
            while(k>1&&c.t[k]==0)--k;
            c.siz=k;
            return c;
        }

        friend bigNum operator /(long long b,bigNum a){
            return a/b;
        }

        friend bigNum operator +(bigNum a,bigNum b){
            bigNum c;
            int g=0,k=max(a.size(),b.size());
            for(int i=1;i<=k;i++){
                c.t[i]=a.t[i]+b.t[i]+g;
                g=c.t[i]/10;
                c.t[i]%=10;
            }
            if(g>0){
                c.t[++k]=g;
            }
            c.siz=k;
            return c;
        }
};

然后是卡特兰数部分,

这道题很玄学的地方在于,用递归在我这里会RE,在洛谷和cqyzoj上就不会。。。

用递推会超时。。。

更正:用太过诡异的递推

递归求法(公式2):

bigNum ktl(int x){
    if(x<=0)return 0;
    if(x==1)return 1;
    if(k[x].size())return k[x];
    else return k[x]=(4*x-2)*ktl(x-1)/(x+1);
}

“太过诡异的”递推求法(公式1):

bigNum ktl(int n){
    for(int i=2;i<=n;++i){
        for(int j=0;j<i;++j){
//          printf("%d %d\n",i,j);
            k[i]=k[i]+(k[j]*k[i-j-1]);
            //ans.print();
        }
    }
    return k[n];
}

(k的声明):

bigNum k[510]={(bigNum)1,(bigNum)1};

以下为完整代码

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

struct bigNum{
    private:
        short t[1005];int siz;

    public:
        bigNum(string a){
            memset(t,0,sizeof(t));
            int len=a.size();
            for(int i=0;i<a.size();++i){
                t[len-i]=a[i];
            }
            siz=len;
        }

        bigNum(void){
            memset(t,0,sizeof(t));
            siz=0;
        }

        bigNum(long long x){
            memset(t,0,sizeof(t));
            int ws=0;
            while(x){
                ++ws;
                int q=x%10;
                x/=10;
                t[ws]=q;
            }
            siz=ws;
        }

        void print(void){
            for(int i=siz;i>=1;--i){
                putchar(t[i]+'0');
            }
            putchar('\n');
        }

        int size(void){
            return siz;
        }

        friend bigNum operator *(bigNum a,long long b){
            bigNum c;
            int len=a.size()+20,g=0;
            for(int i=1;i<=len;++i){
                c.t[i]=a.t[i]*b;
            }
            for(int i=1;i<=len;++i){
                if(c.t[i]>9){
                    c.t[i+1]+=c.t[i]/10;
                    c.t[i]=c.t[i]%10;
                }
            }
            while(len>1&&c.t[len]==0)--len;
            c.siz=len;
            return c;
        }

        friend bigNum operator *(long long b,bigNum a){
            return a*b;
        }

        friend bigNum operator *(bigNum a,bigNum b){
            bigNum c;
            int len=a.size()+b.size();
            for(int i=1;i<=a.size();++i){
                for(int j=1;j<=b.size();++j){
                    c.t[i+j-1]+=(a.t[i]*b.t[j]);
                }
            }

            for(int i=1;i<=len;++i){
                if(c.t[i]>9){
                    c.t[i+1]+=c.t[i]/10;
                    c.t[i]=c.t[i]%10;
                }
            }
            while(len>1 && c.t[len]==0)len--;
            c.siz=len;
            return c;
        }

        friend bigNum operator /(bigNum a,long long b){
            bigNum c;
            int k=a.size(),g=0;
            for(int i=k;i>0;--i){
                g=g*10+a.t[i];
                c.t[i]=g/b;
                g%=b;
            }
            while(k>1&&c.t[k]==0)--k;
            c.siz=k;
            return c;
        }

        friend bigNum operator /(long long b,bigNum a){
            return a/b;
        }

        friend bigNum operator +(bigNum a,bigNum b){
            bigNum c;
            int g=0,k=max(a.size(),b.size());
            for(int i=1;i<=k;i++){
                c.t[i]=a.t[i]+b.t[i]+g;
                g=c.t[i]/10;
                c.t[i]%=10;
            }
            if(g>0){
                c.t[++k]=g;
            }
            c.siz=k;
            return c;
        }
};

bigNum k[510]={(bigNum)1,(bigNum)1};

/*bigNum ktl(int x){
    if(x<=0)return 0;
    if(x==1)return 1;
    if(k[x].size())return k[x];
    else return k[x]=(4*x-2)*ktl(x-1)/(x+1);
}*/

bigNum ktl(int n){
    for(int i=2;i<=n;++i){
        k[i]=(4*i-2)*k[i-1]/(i+1);
    }
    return k[n];
}

int main(void){
    int n;
    cin>>n;
    ktl(n).print();
//  bigNum a(123),b(45);
//  (a*b).print();
    return 0;
}

原文地址:https://www.cnblogs.com/buringstraw/p/10328070.html

时间: 2024-08-29 11:25:19

[AHOI2012]树屋阶梯的相关文章

洛谷P2532 [AHOI2012]树屋阶梯(Catalan数)

P2532 [AHOI2012]树屋阶梯 题目描述 输入输出格式 输入格式: 一个正整数N(1<=N<=500),表示阶梯的高度. 输出格式: 一个正整数,表示搭建方法的个数.(注:搭建方法的个数可能很大) 输入输出样例 输入样例#1: 3 输出样例#1: 5 说明 40%的数据:1<=N<=20 80%的数据:1<=N<=300 100%的数据:1<=N<=500 /* Catalan数套个高精 */ #include<iostream> #i

bzoj2822[AHOI2012]树屋阶梯(卡特兰数)

2822: [AHOI2012]树屋阶梯 Time Limit: 1 Sec  Memory Limit: 128 MBSubmit: 879  Solved: 513[Submit][Status][Discuss] Description 暑假期间,小龙报名了一个模拟野外生存作战训练班来锻炼体魄,训练的第一个晚上,教官就给他们出了个难题.由于地上露营湿气重,必须选择在高处的树屋露营.小龙分配的树屋建立在一颗高度为N+1尺(N为正整数)的大树上,正当他发愁怎么爬上去的时候,发现旁边堆满了一些空

[AHOI2012]树屋阶梯 题解(卡特兰数)

[AHOI2012]树屋阶梯 Description 暑假期间,小龙报名了一个模拟野外生存作战训练班来锻炼体魄,训练的第一个晚上,教官就给他们出了个难题.由于地上露营湿气重,必须选择在高处的树屋露营.小龙分配的树屋建立在一颗高度为N+1尺(N为正整数)的大树上,正当他发愁怎么爬上去的时候,发现旁边堆满了一些空心四方钢材(如图1.1),经过观察和测量,这些钢材截面的宽和高大小不一,但都是1尺的整数倍,教官命令队员们每人选取N个空心钢材来搭建一个总高度为N尺的阶梯来进入树屋,该阶梯每一步台阶的高度为

P2532 [AHOI2012]树屋阶梯

题面:https://www.luogu.org/problem/P2532 本题我们可以发现对于任何大小为 i 的树屋阶梯,都可以由左上角放一块大小为 j 的以及右下角放一块大小为 i?j?1 的树屋阶梯,再在空缺的地方由单个大块的矩形填充即可构成,这个构成的树屋阶梯一共有 (j)+(i?j?1)+1个钢材,正好是 i 个. 那么这里0<=j<=i-1,则答案为h(0)*h(i-1)+h(1)*(i-2)+...+h(i-1)*h(0)(卡特兰数经典递推式) Code: #include&l

bzoj2822 [AHOI2012]树屋阶梯

Description 暑假期间,小龙报名了一个模拟野外生存作战训练班来锻炼体魄,训练的第一个晚上,教官就给他们出了个难题.由于地上露营湿气重,必须选择在高处的树屋露营.小龙分配的树屋建立在一颗高度为N+1尺(N为正整数)的大树上,正当他发愁怎么爬上去的时候,发现旁边堆满了一些空心四方钢材(如图1.1),经过观察和测量,这些钢材截面的宽和高大小不一,但都是1尺的整数倍,教官命令队员们每人选取N个空心钢材来搭建一个总高度为N尺的阶梯来进入树屋,该阶梯每一步台阶的高度为1尺,宽度也为1尺.如果这些钢

2822. [AHOI2012]树屋阶梯【卡特兰数】

Description 暑假期间,小龙报名了一个模拟野外生存作战训练班来锻炼体魄,训练的第一个晚上,教官就给他们出了个难题.由于地上露营湿气重,必须选择在高处的树屋露营.小龙分配的树屋建立在一颗高度为N+1尺(N为正整数)的大树上,正当他发愁怎么爬上去的时候,发现旁边堆满了一些空心四方钢材(如图1.1),经过观察和测量,这些钢材截面的宽和高大小不一,但都是1尺的整数倍,教官命令队员们每人选取N个空心钢材来搭建一个总高度为N尺的阶梯来进入树屋,该阶梯每一步台阶的高度为1尺,宽度也为1尺.如果这些钢

BZOJ 2822: [AHOI2012]树屋阶梯

Description 求拼成阶梯状的方案数. Sol 高精度+Catalan数. 我们可以把最后一行无线延伸,所有就很容易看出Catalan数了. \(f_n=f_0f_{n-1}+f_1f_{n-2}+f_2f_{n-3}+...+f_{n-1}f_0\) 这就是Catalan数了,高精贴板子... Code /************************************************************** Problem: 2822 User: BeiYu La

BZOJ 2822 AHOI2012 树屋阶梯 卡特兰数

题目大意:求n个矩形搭出n级阶梯的方案数 那个什么空心不能向上完全是逗你的- - 卡特兰数的应用之一- - Wiki上有说- - 具体证明不会- - 总之Python大法好- - n=int(raw_input()) temp=1 for i in range (1,n+1): temp=temp*(4*i-2)/(i+1) print temp

【BZOJ 2822】[AHOI2012]树屋阶梯 卡特兰数+高精

这道题随便弄几个数就发现是卡特兰数然而为什么是呢? 我们发现我们在增加一列时,如果这一个东西(那一列)他就一格,那么就是上一次的方案数,并没有任何改变,他占满了也是,然后他要是占两格呢,就是把原来的切成了n-2,和1,要是就剩一格呢,也是把原来的切成一格和n-2,因为如果一行的某一列被堵了那么这一行的开头的那个台阶表面就覆盖不到那一列..... 这个是从数学角度,由于递推公式的相似性所以是卡特兰数....... #include <cstdio> const int STD=10000; st