卡特兰数 性质及应用

最新推荐文章于 2022-07-07 20:12:44 发布
最新推荐文章于 2022-07-07 20:12:44 发布
阅读量1.6k 收藏 2
点赞数 3
分类专栏： 数学 文章标签： 数学 应用 递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013008291/article/details/40265123
版权

卡塔兰数是组合数学中一个常在各种计数问题中出现的数列。以比利时的数学家欧仁·查理·卡塔兰（1814–1894）命名。历史上，清代数学家明安图(1692年－1763年)在其《割圜密率捷法》最早用到“卡塔兰数”，远远早于卡塔兰[1][2][3]。有中国学者建议将此数命名为“明安图数”或“明安图-卡塔兰数”[4]。

卡塔兰数的一般项公式为 C_n = \frac{1}{n+1}{2n \choose n} = \frac{(2n)!}{(n+1)!n!}

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


性质[编辑]

Cn的另一个表达形式为C_n = {2n\choose n} - {2n\choose n+1} \quad\mbox{ for }n\ge 1 所以，Cn是一个自然数；这一点在先前的通项公式中并不显而易见。这个表达形式也是André对前一公式证明的基础。(见下文的第二个证明。)

递推关系

C_0 = 1 \quad \mbox{and} \quad C_{n+1}=\sum_{i=0}^{n}C_i\,C_{n-i}\quad\mbox{for }n\ge 0.

它也满足

C_0 = 1 \quad \mbox{and} \quad C_{n+1}=\frac{2(2n+1)}{n+2}C_n,

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

卡塔兰数的渐近增长为

C_n \sim \frac{4^n}{n^{3/2}\sqrt{\pi}}

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

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

应用[编辑]

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

  • Cn表示长度2n的dyck word的个数。Dyck word是一个有n个X和n个Y组成的字串，且所有的前缀字串皆满足X的个数大于等于Y的个数。以下为长度为6的dyck words:
XXXYYY XYXXYY XYXYXY XXYYXY XXYXYY
  • 将上例的X换成左括号，Y换成右括号，Cn表示所有包含n组括号的合法运算式的个数：
((())) ()(()) ()()() (())() (()())
  • Cn表示有n个节点组成不同构二叉树的方案数。下图中，n等于3，圆形表示节点，月牙形表示什么都没有。
  • Cn表示有2n+1个节点组成不同构满二叉树（full binary tree）的方案数。下图中，n等于3，圆形表示内部节点，月牙形表示外部节点。本质同上。
Catalan number binary tree example.png

证明：

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

考虑一个含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 = {2n \choose n} - {2n \choose n + 1} = \frac{1}{n+1}{2n \choose n}。证毕。

  • Cn表示所有在n × n格点中不越过对角线的单调路径的个数。一个单调路径从格点左下角出发，在格点右上角结束，每一步均为向上或向右。计算这种路径的个数等价于计算Dyck word的个数：X代表“向右”，Y代表“向上”。下图为n = 4的情况：
Catalan number 4x4 grid example.svg
  • Cn表示通过连结顶点而将n + 2边的凸多边形分成三角形的方法个数。下图中为n = 4的情况：
Catalan-Hexagons-example.svg
  • Cn表示对{1, ..., n}依序进出栈的置换个数。一个置换w是依序进出栈的当S(w) = (1, ..., n),其中S（w）递归定义如下：令w = unv，其中n为w的最大元素，u和v为更短的数列；再令S(w) = S(u)S(v)n，其中S为所有含一个元素的数列的单位元。
  • Cn表示用n个长方形填充一个高度为n的阶梯状图形的方法个数。下图为n = 4的情况：
Catalan stairsteps 4.svg
  • Cn表示表为2×n的矩阵的标准杨氏矩阵的数量。 也就是说，它是数字 1, 2, ..., 2n 被放置在一个2×n的矩形中并保证每行每列的数字升序排列的方案数。同样的，该式可由勾长公式的一个特殊情形推导得出。
  • Cn表示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;
}


fisty
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
卡特兰数的应用
lidiyang1993的专栏
04-22 1372
参考http://blog.csdn.net/wuzhekai1985 四种典型的应用：（括号化/出栈顺序/凸多边形三角划分/给顶节点组成二叉树的问题） 1、递推公式 令h(0)=1,h(1)=1，catalan卡特兰数满足递推式： h(n)= h(0)*h(n-1)+h(1)*h(n-2) + ... + h(n-1)h(0) (n>=2) 例如：h(2)=h(0)
组合数学 —— 卡特兰数列（Catalan）
Alex_McAvoy的博客
04-24 3295
【概述】 卡特兰数列是组合数学中一个常出现在各种计数问题中出现的数列，其前几项为 : 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, ...... 卡特兰数首先是由欧拉在计算对凸 n 边形的不同的对角三角形剖分的个数问题时得到的，即在一个凸 n 边形中，通过不相交于 n 边形内部的对角线，把 n 边形拆分成若干三角...
Catalan 数列的性质及其应用（转载）
asd420406的博客
10-22 360
转自：http://lanqi.org/skills/10939/ 　　 卡特兰数 — 计数的映射方法的伟大胜利 发表于2015年11月8日由意琦行 卡特兰（Catalan）数来源于卡特兰解决凸$n+2$边形的剖分时得到的数列$C_n$，在数学竞赛、信息学竞赛、组合数学、计算机编程等方面都会有其不同侧面的介绍．卡特兰问题的解决过程应用了大量的映射方法，堪称计...
卡特兰数的性质
Everything can be done!
08-07 338
令h(0)=1,h(1)=1，catalan数满足递推式： h(n)= h(0)*h(n-1)+h(1)*h(n-2) + ... + h(n-1)*h(0) (n>=2) 例如：h(2)=h(0)*h(1)+h(1)*h(0)=1*1+1*1=2 h(3)=h(0)*h(2)+h(1)*h(1)+h(2)*h(0)=1*2+1*1+2*1=5 另类递推式： h(n)=h(n-1)*(4
卡特兰数及其应用
Harrison的学习博客
04-08 1665
前言 A和B是两个毫不相关的集合，但是集合的个数可数。只要能找到某一个映射 f ，让A集合里的一个样本x只对应B集合里的一个样本y；同时能找到一个映射g，让B里的某一个样本只对应A里的某一个样本。其中，f，g，A，B毫无关系，可以得到A的集合数量等于B的集合数量。 卡特兰数 卡特兰数又称卡塔兰数，英文名Catalan number，是组合数学中一个常出现在各种计数问题中出现的数列。其前几项为： 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 2
卡特兰数应用
weixin_33969116的博客
08-01 99
下面应用转自Wikipedia（http://zh.wikipedia.org/wiki/%E5%8D%A1%E5%A1%94%E5%85%B0%E6%95%B0）： 组合数学中有非常多的组合结构可以用卡塔兰数来计数。在Richard P. Stanley的Enumerative Combinatorics: Volume 2一书的习题中包括了66个相异的可由卡塔兰数表达的组合结构。以下用n=3...
深入理解卡特兰数及其应用
09-05
这是卡特兰数的闭合形式，利用组合数的性质，可以直接计算出第n个卡特兰数。 卡特兰数的应用非常广泛。在计算机科学中，它们常常用于解决排列组合问题。例如： 1. **n个元素顺序入栈，出栈顺序有多少种？** 这个...
卡特兰数字
04-06
卡特兰数（Catalan Numbers）是一组在数学中广泛应用的整数序列，它们以比利时数学家欧仁·查尔斯·卡特兰的名字命名。...在ACM竞赛中，掌握卡特兰数的性质和应用，无疑能提升参赛者的算法能力和问题解决能力。
卡特兰数（Catalan）
01-26
卡特兰数具有多种不同的定义和有趣的性质，其中一种常见的定义是与凸多边形的不相交对角线划分有关。 对于一个凸n边形，我们可以用不相交的对角线将其划分为多个三角形。例如，一个五边形有五种不同的划分方式，...
ACM模板 卡特兰数和博弈论
06-06
本文将结合这两门学科中的经典问题——卡特兰数以及几种常见的博弈论游戏，如Bash Game、Wythoff's Game和Nim Game等，来探讨它们的解法和应用。 #### 二、卡特兰数 卡特兰数是一组自然数序列，常出现在各种组合...
母函数的运用
05-18
### 母函数在求解卡特兰数中的应用 #### 一、母函数与卡特兰数的基础概念 在组合数学中，**母函数**是一种用来表示序列的方法，通过构造一个函数使得该函数的系数对应原序列的值。利用母函数可以非常方便地解决...
Catalan数的分析和应用
06-10 7298
【Catalan数——卡特兰数】一.Catalan数的定义令h(1)=1，Catalan数满足递归式：h(n) = h(1)*h(n-1) + h(2)*h(n-2) + ... + h(n-1)h(1)，n>=2该递推关系的解为：h(n) = C(2n-2,n-1)/n，n=1,2,3,...（其中C(2n-2,n-1)表示2n-2个中取n-1个的组合数）二.Catalan数公式推导截图
卡特兰数的应用，你知道几个？
zhangmh93425的专栏
03-27 7801
卡特兰递推公式 1.    2. 3. 4. 5. 卡特兰数的应用 1. 由n个+1和n个-1构成2n项其部分和满足的序列个数等于第n个Catalan数。 假设不满足条件的序列个数为，那么就有。而对于不满足的序列，必然存在某一个奇数位使，而且+1的个数恰好比-1的个数少一个，此时我们将前k项中的+1变为-1，将-1变为+1,那么就得到一个有(n+1)
卡特兰数（Catalan）相关应用
GKxx
04-20 368
关于卡特兰数这玩意，其实最早是为了准备NOIP初赛而学的（包括斯特林数），不过那时候也没意识到它这么好玩。 这几天好像经常看到关于卡特兰数的一些应用，尤其是文化课数学正好在学计数，所以就决定写一篇总结一下。 为了给非竞赛生更好的阅读体验不至于一上来就被大量的公式劝退，我先介绍卡特兰数的应用，再推导公式。 当你看到这些时，它对应了卡特兰数 我们用CnC_nCn​表示第nnn个卡特兰数，其中n∈Nn\...
卡特兰数介绍及其应用
yetong_
02-12 1022
卡特兰数卡特兰数又称卡塔兰数，英文名Catalan number，是组合数学中一个常出现在各种计数问题中出现的数列。以比利时的数学家欧仁·查理·卡塔兰 (1814–1894)的名字来命名，其前几项为 : 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786…… 其递推式： h(n)=h(0)∗h(n−1)+h(1)∗h(n−2)+...+h(
Catalan数计算及应用
A5656665656556的博客
09-07 348
Catalan数列是非常奇妙的一列数字，因为很多问题的解就是一个Catalan数。知道了这一规律，很多看似复杂的问题便可迎刃而解。那么什么是Catalan数，什么样的问题的解是Catalan数呢？ 1，Catalan数 先来看一段Catalan数列：1,1,2,5,14,42,132,429,1430,4862,16796，即 h(0)=1,h(1)=1,h(2)=2,h(3)=5....
【转】卡特兰数及其应用
weixin_30905981的博客
02-23 141
一、 卡特兰数 1、卡特兰数是满足下列递归式的数字： h(n)=h(0)h(n-1)+h(1)h(n-2)+h(2)h(n-3)+…+h(i)h(n-i-1)+…+h(n-1)h(0)(n>=2) 且，h(0)=1,h(1)=1 2、另一个递归式 h(n)=((4*n-2)/(n+1))*h(n-1) 它的解是：h(n)...
卡特兰数定理以及常用应用
WSY444的博客
07-07 1818
卡特兰数
探索卡特兰数：组合与应用的特殊序列
卡特兰数(Catalan numbers)，以其简洁的定义和广泛的数学应用而闻名。...卡特兰数是数学中一个既简单又深刻的数列，它的独特性质使得它在多个学术领域都有着重要的地位，展示了数学理论如何解决实际问题的优雅之处。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值