学习卡特兰数的一点心得

思路来源

卡特兰数通项公式

卡特兰数递推公式

令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(n)=h(n-1)(4n-2)/(n+1);（可用于大数求递推式）**

递推关系的解为：

h(n)=C(2n,n)/(n+1) (n=0,1,2,...)

递推关系的另类解为：

h(n)=c(2n,n)-c(2n,n-1)(n=0,1,2,...)

卡特兰数的应用

①n个+1和n个-1构成2n项 a_1,a_2,...,a_n ，其部分和满足 a_1 + a_2 + ... + a_k /ge 0 /quad , /quad 0 /le k /le 2n 的序列个数等于第n个Catalan数 C_n 。

证明：

假设不满足条件的序列个数为 U_n ，那么就有 $C_n + U_n = {2n /choose n}$ 。

我们假设有一个最小的k令 a_1 + a_2 + ... + a_k < 0 。

由于这里k是最小的，所以必有 $a_1 + a_2 + ... + a_{k - 1} = 0 /quad , /quad a_k = -1$ ，并且k是一个奇数。

此时我们将前k项中的+1变为-1，将-1变为+1,那么就得到一个有(n+1)个+1和(n-1)个-1的序列了。

这样的序列个数就是我们要求的 U_n 。

显然，Un分为两部分，

先出现-1的序列，其前缀和小于0，将序列最末一个+1改为-1即符合题意；

先出现+1的序列，按上述原则翻转回去，则符合原题意。

故只需在2n个数里任取(n+1)个数为1即可，数值大小为 $U_n = {2n/choose n + 1}$ 。

那么我们就得到了 $C_n = {2n/choose n} - U_n = {2n/choose n} - {2n/choose n + 1}}}$ ，就是我们前面的公式。

②若将+1改为左括号，-1改为右括号，则原问题变为括号的匹配问题。

括号的合法序列是指，对于任意的前缀，左括号数都不少于右括号数，显然是一个卡特兰数。

证明：

（1）空串是合法序列

（2）若A是合法序列且B是合法序列，则AB是合法序列

（3）若S为合法序列，且a为长度为k的左括号，b为长度为k的右括号，则aSb是合法序列

规定A是一个合法序列，B也是一个合法序列。

那么对于n对的括号序列，一定是A(B)的形式构成。

这里我们分别讨论假设，

B有0对括号，则A有(n-1)对；

B有1对……，

……

B有(n-1)对，则A有0对。

故f(n)=f(0)f(n-1)+…+f(n-1)f(0)，

根据卡特兰数的定义，显然是卡特兰数Cn。

③n个节点的二叉树的所有可能形态数为 C_n 。

我们考虑随便取一个节点作为根，那么他左边和右边的儿子节点个数就确定了。

假定根节点标号为x，

那么左子树的标号就从1到x-1,共x-1个，右子树的标号就从x+1到n，共n-x个。

那么我们的x从1取到n，就获得了所有的情况数 $/begin{displaymath}C_n = /sum_{i = 0}^{n - 1}C_i/,C_{n - i - 1}/end{displaymath}$ 。

④求解路径方案数：

对于一个n*n的正方形网格，每次我们能向右或者向上移动一格，

那么从左下角到右上角的所有在副对角线右下方的路径总数为 C_n 。

我们将一条水平边记为+1,垂直边记为-1,那么就组成了一个n个+1和n个-1的序列，

我们所要保证的就是前k步中水平边的个数不小于垂直边的个数，

换句话说前k个元素的和非负，即卡特兰数定义。

⑤求01串的个数：

n个0与n个1构成的序列方案数，使得任何一个前缀0的个数不少于1的个数。

显然把0改为左括号，1改为右括号就变成了合法括号序列匹配问题。

⑥求凸边形进行三角剖分的不同方案数：

在一个有n+3条边的凸多边形中，求通过若干条互不相交的对角线，把这个多边形划分成若干个三角形的不同方案数。

因为每一条边都一定是剖分后的三角形的一条边，

任意一条边都会把多边形分成两个小多边形，

那么根据乘法原理，解即为划分成不同多边形的方案数对应小多边形的划分方案数之和。

⑦求出栈方案数：

我们会把n个数分成两部分来处理。

就是必须等第一部分全部排空后，第二部分的数才能入栈。

两部分分别对应一个方案数，互不相干，线性求积。

1和n-1是独立的两部分。公式就是f(1)*f(n-1)，

如果2和n-2是独立的两部分。公式就是f(2)*f(n-2)，

以此类推，就最终可以推到f(n-1)*f(1)，

线性相加，即卡特兰数。

总结

方案数是卡特兰数的特征，

①可以以某位置为划分，将原情况划分为两个更小的子情况。

②类似前缀和非负的操作，如左括号数不少于右括号数等。

代码实现（大数卡特兰数）

#include <iostream>
#include <algorithm> 
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <stack>
#include <queue>
#include <bitset> 
const int INF=0x3f3f3f3f;
const int MOD=1e9+7;
const double eps=1e-7;
typedef long long ll;
#define vi vector<int> 
#define si set<int>
#define pii pair<int,int> 
#define pi acos(-1.0)
#define pb push_back
#define mp make_pair
#define lowbit(x) (x&(-x))
#define sci(x) scanf("%d",&(x))
#define scll(x) scanf("%lld",&(x))
#define sclf(x) scanf("%lf",&(x))
#define pri(x) printf("%d",(x))
#define rep(i,j,k) for(int i=j;i<=k;++i)
#define per(i,j,k) for(int i=j;i>=k;--i)
#define mem(a,b) memset(a,b,sizeof(a)) 
using namespace std;
const int maxn=1500;
struct BigInt
{
    const static int mod=10000;
    const static int LEN=4;
    int a[maxn],len;
    BigInt()
    {
        memset(a,0,sizeof(a));
        len=1;
    }
    void init(int x)
    {
        memset(a,0,sizeof(a));
        len=0;
        do//四位一存 如123456789存为 6789 2345 1 
        {
            a[len++]=x%mod;
            x/=mod;
        }while(x);
    }
    void Init(const char s[])//重点 123 4567
    {
        memset(a,0,sizeof(a));
        int l=strlen(s),res=0;
        len=l/LEN;
        if(l%LEN)len++;//l/LEN向上取整 len=2 表明需要两个字节能存下 
        for(int i=l-1;i>=0;i-=LEN)
        {
            int t=0,k=max(i-LEN+1,0);//k是找到当前字节的最高位 回退len-1长 防越界 
            for(int j=k;j<=i;j++)t=t*10+s[j]-'0';//从4开始 t临时存储4567 
            a[res++]=t;//将低位存入 
        }
    } 
    int Compare(const BigInt &b)//位多的大 
    {
        if(len<b.len)return -1;
        if(len>b.len)return 1;
        for(int i=len-1;i>=0;i--)//从高位比较 
            if(a[i]<b.a[i])return -1;
            else if(a[i]>b.a[i])return 1;
        return 0;//完全相等的情况 
    }
    BigInt operator +(const BigInt &b)const
    {
        BigInt ans;
        ans.len=max(len,b.len);
        for(int i=0;i<=ans.len;i++)ans.a[i]=0;
        for(int i=0;i<ans.len;i++)
        {
            ans.a[i]+=((i<len)?a[i]:0)+((i<b.len)?b.a[i]:0);//防止越位现象 
            ans.a[i+1]+=ans.a[i]/mod;//向高位进位 
            ans.a[i]%=mod;
        }
        if(ans.a[ans.len]>0)ans.len++;//产生了9999+9999=9998 1的数组高位进位 
        return ans;
    }
    BigInt operator -(const BigInt &b)const//确保被减数大 差为正 
    {
        BigInt ans;
        ans.len=len;
        int k=0;
        for(int i=0;i<ans.len;i++)
        {
            ans.a[i]=a[i]+k-b.a[i];
            if(ans.a[i]<0)ans.a[i]+=mod,k=-1;//向a[i]高位借10000,k=-1下轮生效 
            else k=0;          
        }
        while(ans.a[ans.len-1]==0&&ans.len>1)ans.len--;//把前缀0去掉 如果ans.len=1时说明a=b差为0 
        return ans;
    }
    BigInt operator *(const BigInt &b)const
    {
        BigInt ans;
        for(int i=0;i<len;i++)
        {
            int k=0;
            for(int j=0;j<b.len;j++)
            {
                int temp=a[i]*b.a[j]+ans.a[i+j]+k;//模拟小学生乘法 i*j加到i+j上去 k为低位来的进位 
                ans.a[i+j]=temp%mod;
                k=temp/mod;//k为向高位进的位 下一轮生效 
            }
            if(k!=0)ans.a[i+b.len]=k;//高位进位 99*99=9801 右起第1位*右起第1位还是能到右起第3位的 
        }
        ans.len=len+b.len;//4位数*4位数不会超过8位数  
        while(ans.a[ans.len-1]==0&&ans.len>1)ans.len--;//查出实际长度 
        return ans;
    }
    BigInt operator /(const int &n)const//被确保被除数大 商为正 
    {
        BigInt ans;
        ans.len=len;
        int k=0;
        for(int i=ans.len-1;i>=0;i--)
        {
            k=k*mod+a[i];//k=上一位来的退位*10000+这一位 
            ans.a[i]=k/n;//这一位除以n 
            k=k%n;//这一位除以n的余数送给下一位,i=0最后一位如57/28余的1直接丢掉 取整  
        }
        while(ans.a[ans.len-1]==0&&ans.len>1)ans.len--;
        return ans;
    }
    void output()
    {
        printf("%d",a[len-1]);//是多少就是多少 没有前缀0 
        for(int i=len-2;i>=0;i--) 
            printf("%04d",a[i]);//包含前缀0 如0001 
        printf("\n");
    }
};
BigInt a[6000];
int main()
{
	int n;
	scanf("%d",&n);
	a[0].init(1),a[1].init(1);
	rep(k,2,n+1)
	{
		int t=4*k-2;
		BigInt temp1,temp2;
		temp1.init(t); 
		a[k]=a[k-1]*temp1;
	    temp2=a[k]/(k+1);
	    a[k]=temp2;
	    //a[k].output();
    }
	a[n+1].output();
    return 0;
}