卡塔蘭數是組合數學中一個常在各種計數問題中出現的數列。以比利時的數學家歐仁·查理·卡塔蘭（1814–1894）命名。歷史上，清代數學家明安圖(1692年－1763年)在其《割圜密率捷法》最早用到“卡塔蘭數”，遠遠早於卡塔蘭^[1][2][3]。有中國學者建議將此數命名為“明安圖數”或“明安圖-卡塔蘭數”^[4]。

卡塔蘭數的一般項公式為

前20項為（OEIS中的數列A000108）：1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190

性質[編輯]

C_n的另一個表達形式為所以，C_n是一個自然數；這一點在先前的通項公式中並不顯而易見。這個表達形式也是André對前一公式證明的基礎。(見下文的第二個證明。)

遞推關係

它也滿足

這提供了一個更快速的方法來計算卡塔蘭數。

卡塔蘭數的漸近增長為

它的含義是當n → ∞時，左式除以右式的商趨向於1。（這可以用n!的斯特靈公式來證明。）

所有的奇卡塔蘭數C_n都滿足。所有其他的卡塔蘭數都是偶數。

應用[編輯]

組合數學中有非常多的組合結構可以用卡塔蘭數來計數。在Richard P. Stanley的Enumerative Combinatorics: Volume 2一書的習題中包括了66個相異的可由卡塔蘭數表達的組合結構。以下用n=3和n=4舉若干例：

• C_n表示長度2n的dyck word的個數。Dyck word是一個有n個X和n個Y組成的字串，且所有的字首字串皆滿足X的個數大於等於Y的個數。以下為長度為6的dyck words:

• 將上例的X換成左括號，Y換成右括號，C_n表示所有包含n組括號的合法運算式的個數：

• C_n表示有n個節點組成不同構二叉樹的方案數。下圖中，n等於3，圓形表示節點，月牙形表示什麼都沒有。

• C_n表示有2n+1個節點組成不同構滿二叉樹（full binary tree）的方案數。下圖中，n
  等於3，圓形表示內部節點，月牙形表示外部節點。本質同上。

證明：

令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。綜合這兩個結論，可以用數學歸納法證明：在魏格納半圓分佈定律中度數大於2的情形下，所有自由的累積量s 為零。 該定律在自由概率論和隨機矩陣理論中非常重要。

• C_n表示用n個長方形填充一個高度為n的階梯狀圖形的方法個數。下圖為n = 4的情況：

• C_n表示表為2×n的矩陣的標準楊氏矩陣的數量。 也就是說，它是數字 1, 2, ..., 2n被放置在一個2×n的矩形中並保證每行每列的數字升序排列的方案數。同樣的，該式可由勾長公式的一個特殊情形推導得出。

• C_n表示n個無標號物品的半序的個數。

附上bin神的模板：

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
using namespace std;
/*
 *  完全大數模板
 *  輸入cin>>a
 *  輸出a.print();
 *  注意這個輸入不能自動去掉前導0的，可以先讀入到char陣列，去掉前導0，再用建構函式。
 */
#define MAXN 9999
#define MAXSIZE 1010
#define DLEN 4
class BigNum
{
        private:
                int a[500];  //可以控制大數的位數
                int len;
        public:
                BigNum(){len=1;memset(a,0,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=0;
        memset(a,0,sizeof(a));
        while(d>MAXN)  
        {
                c=d-(d/(MAXN+1))*(MAXN+1);
                d=d/(MAXN+1);
                a[len++]=c;
        }
        a[len++]=d;
}
BigNum::BigNum(const  char *s)  //將一個字串型別的變數轉化為大數
{
        int t,k,index,L,i;
        memset(a,0,sizeof(a));
        L=strlen(s);
        len=L/DLEN;
        if(L%DLEN)len++;
        index=0;
        for(i=L-1;i>=0;i-=DLEN)
        {
                t=0;
                k=i-DLEN+1;
                if(k<0)k=0;
                for(int j=k;j<=i;j++)
                        t=t*10+s[j]-'0';
                a[index++]=t;
        }
}
BigNum::BigNum(const  BigNum  &T):len(T.len)   //拷貝建構函式
{
        int i;
        memset(a,0,sizeof(a));
        for(i=0;i<len;i++)
                a[i]=T.a[i];
}
BigNum & BigNum::operator=(const  BigNum &n)  //過載賦值運算子，大數之間賦值運算
{
        int i;
        len=n.len;
        memset(a,0,sizeof(a));
        for(i=0;i<len;i++)
                a[i]=n.a[i];
        return *this;
}
istream& operator>>(istream &in,BigNum &b)
{
        char ch[MAXSIZE*4];
        int i=-1;
        in>>ch;
        int L=strlen(ch);
        int count=0,sum=0;
        for(i=L-1;i>=0;)
        {
                sum=0;
                int t=1;
                for(int j=0;j<4&&i>=0;j++,i--,t*=10)
                {
                        sum+=(ch[i]-'0')*t;
                }
                b.a[count]=sum;
                count++;  
        }
        b.len=count++;
        return in;
}
ostream&  operator<<(ostream&  out,BigNum&  b)  //過載輸出運算子
{
        int i;
        cout<<b.a[b.len-1];
        for(i=b.len-2;i>=0;i--)
        {
                printf("%04d",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=0;i<big;i++)
        {
                t.a[i]+=T.a[i];
                if(t.a[i]>MAXN)
                {
                        t.a[i+1]++;
                        t.a[i]-=MAXN+1;
                }
        }
        if(t.a[big]!=0)
                t.len=big+1;
        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=0;
        }
        else
        {
                t1=T;
                t2=*this;
                flag=1;
        }
        big=t1. len;
        for(i=0;i<big;i++)
        {
                if(t1.a[i]<t2.a[i])
                {
                        j=i+1;
                        while(t1.a[j]==0)
                                j++; 
                        t1.a[j--]--;
                        while(j>i)
                                t1.a[j--]+=MAXN;
                        t1.a[i]+=MAXN+1-t2.a[i];
                }
                else t1.a[i]-=t2.a[i];
        }
        t1.len=big;
        while(t1.a[len-1]==0 && t1.len>1)
        {
                t1.len--;
                big--;
        }
        if(flag)
                t1.a[big-1]=0-t1.a[big-1];
        return t1;
}
BigNum BigNum::operator*(const  BigNum  &T)const  //兩個大數之間的相乘
{
        BigNum ret;
        int i,j,up;
        int temp,temp1;
        for(i=0;i<len;i++)
        {
                up=0;
                for(j=0;j<T. len;j++)
                {
                        temp=a[i]*T.a[j]+ret. a[i+j]+up;
                        if(temp>MAXN)
                        {
                                temp1=temp-temp/(MAXN+1)*(MAXN+1);
                                up=temp/(MAXN+1);
                                ret.a[i+j]=temp1;
                        }
                        else
                        {
                                up=0;
                                ret.a[i+j]=temp;
                        }
                }
                if(up!=0)
                        ret.a[i+j]=up;
        }
        ret.len=i+j;
        while(ret.a[ret.len-1]==0 && ret.len>1)ret.len--;
        return ret;
}
BigNum BigNum::operator/(const  int &b)const  //大數對一個整數進行相除運算
{
        BigNum ret;
        int i,down=0;
        for(i=len-1;i>=0;i--)
        {
                ret.a[i]=(a[i]+down*(MAXN+1))/b;
                down=a[i]+down*(MAXN+1)-ret.a[i]*b;
        }
        ret.len=len;
        while(ret.a[ret.len-1]==0 && ret.len>1) 
                ret.len--;
        return ret;
}
int BigNum::operator%(const  int &b)const  //大數對一個 int型別的變數進行取模
{
        int i,d=0;
        for(i=len-1;i>=0;i--)
                d=((d*(MAXN+1))%b+a[i])%b;
        return d;
}
BigNum BigNum::operator^(const  int &n)const  //大數的n次方運算
{
        BigNum t,ret(1);
        int i;
        if(n<0)exit(-1);
        if(n==0)return 1;
        if(n==1)return *this;
        int m=n;
        while(m>1)
        {
                t=*this;
                for(i=1;(i<<1)<=m;i<<=1)
                        t=t*t;
                m-=i;
                ret=ret*t;
                if(m==1)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-1;
                while(a[ln]==T.a[ln]&&ln>=0)
                        ln--;
                if(ln>=0 &&  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;
        printf("%d",a[len-1]);
        for(i=len-2;i>=0;i--)
                printf("%04d",a[i]);
        printf("\n"); 
}
BigNum f[110];//卡特蘭數
int main()
{
        f[0]=1;
        for(int i=1;i<=100;i++)
                f[i]=f[i-1]*(4*i-2)/(i+1); //卡特蘭數遞推式
        int n;
        while(scanf("%d",&n)==1)
        {
                if(n==-1)break;
                f[n].print();
        }
        return 0;
}