#include<iostream>

 #include<string>

 #include<iomanip>

 #include<algorithm>

 using namespace std; 

 #define MAXN 9999

 #define MAXSIZE 10

 #define DLEN 4

 class BigNum

 {

 private:

     int a[];    //可以控制大数的位数

     int len;       //大数长度

 public:

     BigNum(){ len = ;memset(a,,sizeof(a)); }   //构造函数

     BigNum(const int);       //将一个int类型的变量转化为大数

     BigNum(const char*);     //将一个字符串类型的变量转化为大数

     BigNum(const BigNum &);  //拷贝构造函数

     BigNum &operator=(const BigNum &);   //重载赋值运算符，大数之间进行赋值运算

     friend istream& operator>>(istream&,  BigNum&);   //重载输入运算符

     friend ostream& operator<<(ostream&,  BigNum&);   //重载输出运算符

     BigNum operator+(const BigNum &) const;   //重载加法运算符，两个大数之间的相加运算

     BigNum operator-(const BigNum &) const;   //重载减法运算符，两个大数之间的相减运算

     BigNum operator*(const BigNum &) const;   //重载乘法运算符，两个大数之间的相乘运算

     BigNum operator/(const int   &) const;    //重载除法运算符，大数对一个整数进行相除运算

     BigNum operator^(const int  &) const;    //大数的n次方运算

     int    operator%(const int  &) const;    //大数对一个int类型的变量进行取模运算

     bool   operator>(const BigNum & T)const;   //大数和另一个大数的大小比较

     bool   operator>(const int & t)const;      //大数和一个int类型的变量的大小比较

     void print();       //输出大数

 };

 BigNum::BigNum(const int b)     //将一个int类型的变量转化为大数

 {

     int c,d = b;

     len = ;

     memset(a,,sizeof(a));

     while(d > MAXN)

     {

         c = d - (d / (MAXN + )) * (MAXN + );

         d = d / (MAXN + );

         a[len++] = c;

     }

     a[len++] = d;

 }

 BigNum::BigNum(const char*s)     //将一个字符串类型的变量转化为大数

 {

     int t,k,index,l,i;

     memset(a,,sizeof(a));

     l=strlen(s);

     len=l/DLEN;

     if(l%DLEN)

         len++;

     index=;

     for(i=l-;i>=;i-=DLEN)

     {

         t=;

         k=i-DLEN+;

         if(k<)

             k=;

         for(int j=k;j<=i;j++)

             t=t*+s[j]-'';

         a[index++]=t;

     }

 }

 BigNum::BigNum(const BigNum & T) : len(T.len)  //拷贝构造函数

 {

     int i;

     memset(a,,sizeof(a));

     for(i =  ; i < len ; i++)

         a[i] = T.a[i];

 }

 BigNum & BigNum::operator=(const BigNum & n)   //重载赋值运算符，大数之间进行赋值运算

 {

     int i;

     len = n.len;

     memset(a,,sizeof(a));

     for(i =  ; i < len ; i++)

         a[i] = n.a[i];

     return *this;

 }

 istream& operator>>(istream & in,  BigNum & b)   //重载输入运算符

 {

     char ch[MAXSIZE*];

     int i = -;

     in>>ch;

     int l=strlen(ch);

     int count=,sum=;

     for(i=l-;i>=;)

     {

         sum = ;

         int t=;

         for(int j=;j<&&i>=;j++,i--,t*=)

         {

             sum+=(ch[i]-'')*t;

         }

         b.a[count]=sum;

         count++;

     }

     b.len =count++;

     return in;

 }

 ostream& operator<<(ostream& out,  BigNum& b)   //重载输出运算符

 {

     int i;

     cout << b.a[b.len - ];

     for(i = b.len -  ; i >=  ; i--)

     {

         cout.width(DLEN);

         cout.fill('');

         cout << b.a[i];

     }

     return out;

 }

 BigNum BigNum::operator+(const BigNum & T) const   //两个大数之间的相加运算

 {

     BigNum t(*this);

     int i,big;      //位数

     big = T.len > len ? T.len : len;

     for(i =  ; i < big ; i++)

     {

         t.a[i] +=T.a[i];

         if(t.a[i] > MAXN)

         {

             t.a[i + ]++;

             t.a[i] -=MAXN+;

         }

     }

     if(t.a[big] != )

         t.len = big + ;

     else

         t.len = big;

     return t;

 }

 BigNum BigNum::operator-(const BigNum & T) const   //两个大数之间的相减运算

 {

     int i,j,big;

     bool flag;

     BigNum t1,t2;

     if(*this>T)

     {

         t1=*this;

         t2=T;

         flag=;

     }

     else

     {

         t1=T;

         t2=*this;

         flag=;

     }

     big=t1.len;

     for(i =  ; i < big ; i++)

     {

         if(t1.a[i] < t2.a[i])

         {

             j = i + ;

             while(t1.a[j] == )

                 j++;

             t1.a[j--]--;

             while(j > i)

                 t1.a[j--] += MAXN;

             t1.a[i] += MAXN +  - t2.a[i];

         }

         else

             t1.a[i] -= t2.a[i];

     }

     t1.len = big;

     while(t1.a[len - ] ==  && t1.len > )

     {

         t1.len--;

         big--;

     }

     if(flag)

         t1.a[big-]=-t1.a[big-];

     return t1;

 } 

 BigNum BigNum::operator*(const BigNum & T) const   //两个大数之间的相乘运算

 {

     BigNum ret;

     int i,j,up;

     int temp,temp1;

     for(i =  ; i < len ; i++)

     {

         up = ;

         for(j =  ; j < T.len ; j++)

         {

             temp = a[i] * T.a[j] + ret.a[i + j] + up;

             if(temp > MAXN)

             {

                 temp1 = temp - temp / (MAXN + ) * (MAXN + );

                 up = temp / (MAXN + );

                 ret.a[i + j] = temp1;

             }

             else

             {

                 up = ;

                 ret.a[i + j] = temp;

             }

         }

         if(up != )

             ret.a[i + j] = up;

     }

     ret.len = i + j;

     while(ret.a[ret.len - ] ==  && ret.len > )

         ret.len--;

     return ret;

 }

 BigNum BigNum::operator/(const int & b) const   //大数对一个整数进行相除运算

 {

     BigNum ret;

     int i,down = ;

     for(i = len -  ; i >=  ; i--)

     {

         ret.a[i] = (a[i] + down * (MAXN + )) / b;

         down = a[i] + down * (MAXN + ) - ret.a[i] * b;

     }

     ret.len = len;

     while(ret.a[ret.len - ] ==  && ret.len > )

         ret.len--;

     return ret;

 }

 int BigNum::operator %(const int & b) const    //大数对一个int类型的变量进行取模运算

 {

     int i,d=;

     for (i = len-; i>=; i--)

     {

         d = ((d * (MAXN+))% b + a[i])% b;

     }

     return d;

 }

 BigNum BigNum::operator^(const int & n) const    //大数的n次方运算

 {

     BigNum t,ret();

     int i;

     if(n<)

         exit(-);

     if(n==)

         return ;

     if(n==)

         return *this;

     int m=n;

     while(m>)

     {

         t=*this;

         for( i=;i<<<=m;i<<=)

         {

             t=t*t;

         }

         m-=i;

         ret=ret*t;

         if(m==)

             ret=ret*(*this);

     }

     return ret;

 }

 bool BigNum::operator>(const BigNum & T) const   //大数和另一个大数的大小比较

 {

     int ln;

     if(len > T.len)

         return true;

     else if(len == T.len)

     {

         ln = len - ;

         while(a[ln] == T.a[ln] && ln >= )

             ln--;

         if(ln >=  && a[ln] > T.a[ln])

             return true;

         else

             return false;

     }

     else

         return false;

 }

 bool BigNum::operator >(const int & t) const    //大数和一个int类型的变量的大小比较

 {

     BigNum b(t);

     return *this>b;

 }

 void BigNum::print()    //输出大数

 {

     int i;

     cout << a[len - ];

     for(i = len -  ; i >=  ; i--)

     {

         cout.width(DLEN);

         cout.fill('');

         cout << a[i];

     }

     cout << endl;

 }

 int main(void)

 {

     int i,n;

     BigNum x[];      //定义大数的对象数组

     x[]=;

     for(i=;i<;i++)

         x[i]=x[i-]*(*i-)/(i+);

     while(scanf("%d",&n)== && n!=-)

     {

         x[n].print();

     }

 }

卡塔兰数是组合数学中一个常出现在各种计数问题中出现的数列。由以比利时的数学家欧仁·查理·卡塔兰 (1814–1894)命名。

卡塔兰数的一般项公式为                       另类递归式：  h(n)=((4*n-2)/(n+1))*h(n-1);

前几项为 （OEIS中的数列A000108）: 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190, 6564120420, 24466267020, 91482563640, 343059613650, 1289904147324, 4861946401452, ...

[性质]

C_n的另一个表达形式为 所以，C_n是一个自然数；这一点在先前的通项公式中并不显而易见。这个表达形式也是André对前一公式证明的基础。(见下文的第二个证明。)

卡塔兰数满足以下递推关系

它也满足

这提供了一个更快速的方法来计算卡塔兰数。

卡塔兰数的渐近增长为

它的含义是左式除以右式的商趋向于1当n → ∞。（这可以用n!的斯特灵公式来证明。）

所有的奇卡塔兰数C_n都满足n = 2^k − 1。所有其他的卡塔兰数都是偶数。

[应用]

组合数学中有非常多.的组合结构可以用卡塔兰数来计数。在Richard P. Stanley的Enumerative Combinatorics: Volume 2一书的习题中包括了66个相异的可由卡塔兰数表达的组合结构。以下用C_n=3和C_n=4举若干例：

• C_n表示长度2n的dyck word的个数。Dyck word是一个有n个X和n个Y组成的字串，且所有的部分字串皆满足X的个数大于等于Y的个数。以下为长度为6的dyck words:

XXXYYY XYXXYY XYXYXY XXYYXY XXYXYY

• 将上例的X换成左括号，Y换成右括号，C_n表示所有包含n组括号的合法运算式的个数:

((())) ()(()) ()()() (())() (()())

• C_n表示有n+1个叶子的二叉树的个数。

• C_n表示所有不同构的含n个分枝结点的满二叉树的个数。（一个有根二叉树是满的当且仅当每个结点都有两个子树或没有子树。）

证明：

令1表示进栈，0表示出栈，则可转化为求一个2n位、含n个1、n个0的二进制数，满足从左往右扫描到任意一位时，经过的0数不多于1数。显然含n个1、n个0的2n位二进制数共有个，下面考虑不满足要求的数目.

考虑一个含n个1、n个0的2n位二进制数，扫描到第2m+1位上时有m+1个0和m个1（容易证明一定存在这样的情况），则后面的0-1排列中必有n-m个1和n-m-1个0。将2m+2及其以后的部分0变成1、1变成0，则对应一个n+1个0和n-1个1的二进制数。反之亦然（相似的思路证明两者一一对应）。

从而。证毕。

• C_n表示所有在n × n格点中不越过对角线的单调路径的个数。一个单调路径从格点左下角出发，在格点右上角结束，每一步均为向上或向右。计算这种路径的个数等价于计算Dyck word的个数： X代表“向右”，Y代表“向上”。下图为n = 4的情况：
• 

• C_n表示通过连结顶点而将n + 2边的凸多边形分成三角形的方法个数。下图中为n = 4的情况：

• C_n表示对{1, ..., n}依序进出栈的置换个数。一个置换w是依序进出栈的当S(w) = (1, ..., n), 其中S(w)递归定义如下：令w = unv，其中n为w的最大元素，u和v为更短的数列；再令S(w) =S(u)S(v)n，其中S为所有含一个元素的数列的单位元。

• C_n表示集合{1, ..., n}的不交叉划分的个数. 那么, C_n 永远不大于第n项贝尔数. C_n也表示集合{1, ..., 2n}的不交叉划分的个数，其中每个段落的长度为2。综合这两个结论，可以用数学归纳法证明 that all of the free cumulants of degree more than 2 of the Wigner semicircle law are zero. This law is important in free probability theory and the theory of random matrices.

• C_n表示用n个长方形填充一个高度为n的阶梯状图形的方法个数。下图为 n = 4的情况: