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
    Language: C++
    Result: Accepted
    Time:20 ms
    Memory:1308 kb
****************************************************************/

#include<cstdio>
#include<cmath>
#include<vector>
#include<algorithm>
#include<iostream>
using namespace std;

typedef long long LL;
const int B = 10;
const int W = 1;

struct Big{
    vector<int> s;
    void clear(){ s.clear(); }

    Big(LL num=0){ *this=num; }
    Big operator = (LL x){
        clear();
        do{ s.push_back(x%B),x/=B; }while(x);
        return *this;
    }
    Big operator = (const string &str){
        clear();
        int x,len=(str.length()-1)/W+1,l=str.length();
        for(int i=0;i<len;i++){
            int tt=l-i*W,st=max(0,tt-W);
            sscanf(str.substr(st,tt-st).c_str(),"%d",&x);
            s.push_back(x);
        }return *this;
    }
};

istream& operator >> (istream & in,Big &a){
    string s;
    if(!(in>>s)) return in;
    a=s;return in;
}

ostream& operator << (ostream &out,const Big &a){
    cout<<a.s.back();
    for(int i=a.s.size()-2;~i;i--){
        cout.width(W),cout.fill(‘0‘),cout<<a.s[i];
    }return out;
}

bool operator < (const Big &a,const Big &b){
    int la=a.s.size(),lb=b.s.size();
    if(la<lb) return 1;if(la>lb) return 0;
    for(int i=la-1;~i;i--){
        if(a.s[i]<b.s[i]) return 1;
        if(a.s[i]>b.s[i]) return 0;
    }return 0;
}
bool operator <= (const Big &a,const Big &b){ return !(b<a); }
bool operator > (const Big &a,const Big &b){ return b<a; }
bool operator >= (const Big &a,const Big &b){ return !(a<b); }
bool operator == (const Big &a,const Big &b){ return !(a>b) && !(a<b); }
bool operator != (const Big &a,const Big &b){ return a>b || a<b ; }

Big operator + (const Big &a,const Big &b){
    Big c;c.clear();
    int lim=max(a.s.size(),b.s.size()),la=a.s.size(),lb=b.s.size(),i,g,x;
    for(i=0,g=0;;i++){
        if(g==0 && i>=lim) break;
        x=g;if(i<la) x+=a.s[i];if(i<lb) x+=b.s[i];
        c.s.push_back(x%B),g=x/B;
    }i=c.s.size()-1;
    while(c.s[i]==0 && i) c.s.pop_back(),i--;
    return c;
}
Big operator - (const Big &a,const Big &b){
    Big c;c.clear();
    int i,g,x,la=a.s.size(),lb=b.s.size();
    for(i=0,g=0;i<la;i++){
        x=a.s[i]-g;
        if(i<lb) x-=b.s[i];
        if(x>=0) g=0;else g=1,x+=B;
        c.s.push_back(x);
    }i=c.s.size()-1;
    while(c.s[i]==0 && i) c.s.pop_back(),i--;
    return c;
}
Big operator * (const Big &a,const Big &b){
    Big c;
    int i,j,la=a.s.size(),lb=b.s.size(),lc=la+lb;
    c.s.resize(lc,0);
    for(i=0;i<la;i++) for(j=0;j<lb;j++) c.s[i+j]+=a.s[i]*b.s[j];
    for(i=0;i<lc;i++) c.s[i+1]+=c.s[i]/B,c.s[i]%=B;
    i=lc-1;while(c.s[i]==0 && i) c.s.pop_back(),i--;
    return c;
}
Big operator / (const Big &a,const Big &b){
    Big c,f=0;
    int la=a.s.size(),i;
    c.s.resize(la,0);
    for(i=la-1;~i;i--){
        f=f*B,f.s[0]=a.s[i];
        while(f>=b) f=f-b,c.s[i]++;
    }i=la-1;while(c.s[i]==0 && i) c.s.pop_back(),i--;
    return c;
}
Big operator % (const Big &a,const Big &b){
    Big c=a-(a/b)*b;
    return c;
}
Big operator ^ (Big &a,Big &b){
    Big c=1;
    for(;b!=0;b=b/2,a=a*a){
        if(b.s[0] & 1) c=c*a;
    }return c;
}
Big operator += (Big &a,const Big &b){ return a=a+b; }
Big operator -= (Big &a,const Big &b){ return a=a-b; }
Big operator *= (Big &a,const Big &b){ return a=a*b; }
Big operator /= (Big &a,const Big &b){ return a=a/b; }
Big operator %= (Big &a,const Big &b){ return a=a%b; }

const int N = 1005;

int cnt;
int b[N],pr[N],minp[N],c[N];

void Pre(int t){
    minp[1]=0;
    for(int i=2;i<=t;i++){
        if(!b[i]) pr[++cnt]=i,minp[i]=cnt;
        for(int j=1;j<=cnt && i*pr[j]<=t;j++){
            b[i*pr[j]]=1,minp[i*pr[j]]=j;
            if(i%pr[j]==0) break;
        }
    }
}
void Add(int x,int v){ while(x>1) c[minp[x]]+=v,x/=pr[minp[x]]; }
int main(){
    ios::sync_with_stdio(false);
    int n;Big ans=1,a,b;
    cin>>n;
    Pre(n*2);

    for(int i=n+1;i<=2*n;i++) Add(i,1);
    for(int i=1;i<n;i++) Add(i,-1);
    Add(n,-1),Add(n+1,-1);

    for(int i=1;i<=cnt;i++) a=pr[i],b=c[i],ans*=a^b;

    cout<<ans<<endl;
    return 0;
}

  

时间: 2024-10-15 05:43:26

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

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

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

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

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

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

洛谷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

[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

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

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

bzoj2822 [AHOI2012]树屋阶梯

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

[AHOI2012]树屋阶梯

同步:http://buringstraw.win/index.php/archives/17/ 题目 输入格式: 一个正整数N(1<=N<=500),表示阶梯的高度. 输出格式: 一个正整数,表示搭建方法的个数.(注:搭建方法的个数可能很大) 分析 通过人肉打表找规律严格证明发现这是个卡特兰数 然后要求到第500项#(喷) 所以这同时也是个优秀的高精度板子 Code 首先是高精度部分(两个板子的codemix) struct bigNum{ private: short t[1005];in