组合数学之卡特兰数

卡特兰数在求解一些组合问题的典型十分有用，如求解元素出栈的方式数量，多边形划分三角形问题等等。原文的最后给出了几道hdoj的相关题目，可以去练习下

原文链接:http://www.cnblogs.com/buptLizer/archive/2011/10/23/2222027.html

2016.11.29再次修改

卡特兰数：

1.通项公式：h(n)=C(n,2n)/(n+1)=(2n)!/((n!)*(n+1)!) = C(n, 2n) - C(n +1, 2n)

2.递推公式：h(n)=((4*n-2)/(n+1))*h(n-1);

                      h(n)=h(0)*h(n-1)+h(1)*h(n-2)+...+h(n-1)*h(0).

3.前几项为：h(0)=1,h(1)=1,h(2)=2,h(3)=5,h(4)=14,h(5)=42,......

4.一些例题：

给出hdu上面的有关例题：

hdoj 1134

2n个人围成一个圆圈，求两两相互握手并且不交叉的所有握手方式。
这个是卡特兰数的一个例子，设2n个人一共有h(n)种，那么现在第一个人可以和第2,4,6，。。。，2（n-1），2n，即必须保证和他握手的那个人两边是偶数，即为：h(n)=h(0)*h(n-1)+h(1)*h(n-2)+...+h(n-1)*h0=(4*n-2)/(n+1) *h(n-1),h(0)=1,h(1)=1.通项公式:h(n)=C(n,2n)/n+1=(2n)!/((n!)*(n+1)!)但是这个题目是大数，所以必须采用数组模拟乘除法.

hdoj1023

求出栈序列，比如1,2,3，出栈序列为3 2 1,1 2 3,1 3 2,2 1 3,2 3 1,一共5种

第一种思路：

我们把入栈看做1，出栈看做0，那么入栈出栈看做一系列的1010。。。，但是必须保证从左往右看的时候1必须多余0，这个是卡塔兰数的第二个应用，种数为：C(n,2n)-C(n+1,2n).粗略这样理解：我们从2n个位置中选出n个来存放1，方法数为C(n,2n),减去不满足的情况。不合法的情况：我们在2n个位置放n+1个0，n-1个1，由于0的个数多2个，2n为偶数，故必在某一个奇数位上出现0的累计数超过1的累计数。同样在后面部分0和1互换，使之成为由n个0和n个1组成的2n位数，即n+1个0和n-1个1组成的2n位数必对应一个不符合要求的数，即C（n+1,2n）。

比如：对于数列10101001010100， 在第7个位置上首先出现了0比1多的情况，而在后面的数列中0的总计数还是比1的总计数多1（n+1个0， n-1个1）。如果把后面数列的0和1互换，那么整个数列就能够保证0和1的计数是相等的。同时对应了一种不符合要求的排列方法：10101000101011.

所以总的方案数为：h(n)=C(n,2n)-C(n+1,2n).

第二种思路：

这种方法直接来源于卡特兰数3的递推公式：h(n) = h(0) * h(n- 1) + h(1) * h(n - 2) + ... + h(n - 1) * h(0)

令f(n)为n个字符的出栈序列的方法数

假设在出栈序列中，在数1在第k个位置出栈，则之前有k-1个字符已经出栈，后面还有n-k个字符未出栈，那么在这种情况下出栈方案数为f(k-1)*f(n-k), k = 1, 2, 3, ...,n

f(0) = 1, f(1) = 1

那么f(n) = f(0) * f(n - 1) + f(1) * f(n - 2) + ... + f(n - 1) * f(0) = h(n)

第三种思路：

使用折现法，这种方法与从(0, 0)到坐标(n ,n)不通过对角线的方法数有异曲同工之妙，具体见：http://blog.sina.com.cn/s/blog_6917f47301010cno.html

hdoj2067

给出一个棋盘n*n，求从左下角到右上角的不经过对角线的所有走法，这个经过分析也是卡特兰数。我们把往右走看做1，把往上走看做0，那么从左向右看做一系列的101100.。。，和那个求出栈序列的就是一个问题了，即0的个数不能超过1，由于上半角和下半角一样，所以求出来卡特兰数*2就是我们的答案了。

注：从(0,0)到(n, n)不 接触 对角线上的点 和从(0, 0)到(n, n)不 穿过 对角线上的点的方法数是不同的。后者可看作n个字符的出栈序列，前者可看作在先在栈中加入一个字符，之后在最后的操作之前栈底不能为空，所以方法数为h(n - 1)。

同样可以使用对称的方法求解:

对于不能接触对角线的方法数的解法为：由于不接触对角线，那么第一步一定走向(1, 0), 倒数第二步的位置一定是(n, n - 1)。那么总的方法数为：C(n - 1, 2n-2)。之后需要减去接触对角线的方法数：如果我们从(0, 1)出发，到达(n, n -1)的路径一定会接触对角线，而这样的路径和从(1, 0)到(n, n -1)不合法的路径是一一对应的的（可以把它从最后离开对角线的点到(1, 0)做一个关于y=x的对称），那么总的方法数为2 * (C(n- 1, 2n - 2) - C(n, 2n - 2)) = 2 * h(n - 1)种方法

对于可以接触但不能穿过对角线的解法为：不能穿过y=x，等价与不能接触y=x+1，所以，从(0, 0) 到(n, n)的总方法数为C(n, 2n)，之后减去不符合要求的方法数。将(0, 0)关于y=x+1做对称可得到点(-1, 1)，从(-1, 1)到点(n, n)必定接触y=x+1，方法数为C(2n - 1, 2n)。所以符合要求的方法数为：C(n, 2n) - C(2n - 1,2n) = C(n, 2n) - C(2n + 1,2n) = h(n)

hdoj1130

给出n个点，求组成二叉树的所有种数，2个点组成2种二叉树，3个点组成5种二叉树。。。
这个也是卡塔兰数的一个应用，和1134类似，我们去除一个点作为根节点，然后左边依次可以取0至N-1个相对应的,右边是N-1到0个,两两配对相乘,就是h(0)*h(n-1) + h(2)*h(n-2) +...+ h(n-1)h(0)=h(n))。

hdoj1133
买票问题：有m个人手里拿的是50元的，n个人拿的是100元的，问使买票过程不中断的排队方式。我们知道如果前面出现拿50的人小于拿100的人，那么肯定出现找不开的情况，我们把拿50的看做0，拿100的看做1，所以从左往右看的时候0的个数必须大于1。

我们知道总的情况为：C(n,m+n),需要求出不合法的序列个数，还是之前的思路，存在一个奇数位置2*k+1，使得0出现k此1出现k+1次，后面会有(m-k)个0，(n-k-1)个1，我们将01交换，即这个序列共有m+1个1，n-1个0，这个序列的所有排序情况就对应了一种不合法的序列情况（可以这样理解：由于m+1>n-1,那么必然在某一个位置出现1的个数大于0的个数，这样在这个位置往后的01我们交换回来，就对于了一种不合法的序列了），即C(m+1,m+n),最后的结果为：ans=C(n,m+n)-C(m+1,m+n),其中(m>=n)；当m<n时买票过程必然中断。

5其他应用场景：

a.括号化问题。
　　矩阵链乘： P=a1×a2×a3×……×an，依据乘法结合律，不改变其顺序，只用括号表示成对的乘积，试问有几种括号化的方案？(h(n - 1)种)
b.出栈次序问题。
　　一个栈(无穷大)的进栈序列为1,2,3,..n,有多少个不同的出栈序列?
　　类似：
　　(1)有2n个人排成一行进入剧场。入场费5元。其中只有n个人有一张5元钞票，另外n人只有10元钞票，剧院无其它钞票，问有多少中方法使得只要有10元的人买票，售票处就有5元的钞票找零？(将持5元者到达视作将5元入栈，持10元者到达视作使栈中某5元出栈)
　　(2)在圆上选择2n个点,将这些点成对连接起来，使得所得到的n条线段不相交的方法数。

c.将多边行划分为三角形问题。
　　(1)将一个凸多边形区域分成三角形区域的方法数?
　　(2)类似：一位大城市的律师在她住所以北n个街区和以东n个街区处工作。每天她走2n个街区去上班。如果她从不穿越（但可以碰到）从家到办公室的对角线，那么有多少条可能的道路？
　　(3)类似：在圆上选择2n个点,将这些点成对连接起来使得所得到的n条线段不相交的方法数?
d.给顶节点组成二叉树的问题。
　　给定N个节点，能构成多少种形状不同的二叉树？
　　(一定是二叉树!先去一个点作为顶点,然后左边依次可以取0至N-1个相对应的,右边是N-1到0个,两两配对相乘,就是

      h(0)*h(n-1) + h(2)*h(n-2) +  + h(n-1)h(0)=h(n))（能构成h（N）个）。

hdu 2067:（其他的几道题都比较相像）

#include <iostream>
#include <cstdio>
#include <cstdlib>

using namespace std;
const int maxn = 130;
const int msize = 40;

struct BIGNUM
{
	int s[maxn];
	int len;
}h[msize];

BIGNUM mutiply(BIGNUM a, int b)
{
	for (int i = 0; i < a.len; i++)
		a.s[i] *= b;

	for (int i = 0; i < a.len; i++)
	{
		if (a.s[i] >= 10)
		{
			a.s[i + 1] += a.s[i] / 10;
			a.s[i] %= 10;
		}
	}

	while (a.s[a.len] != 0)
	{
		a.s[a.len + 1] += a.s[a.len] / 10;
		a.s[a.len] %= 10;
		a.len++;
	}

	return a;
}

BIGNUM divide(BIGNUM a, int b)
{
	for (int i = a.len - 1; i > 0; i--)
	{
		a.s[i - 1] += a.s[i] % b * 10;
		a.s[i] /= b;
	}

	a.s[0] /= b;
	while (0 == a.s[a.len - 1])
		a.len--;

	return a;
}

void init()
{
	h[0].len = 1;
	h[0].s[0] = 1;

	for (int i = 1; i < msize; i++)
	{
		h[i] = mutiply(h[i - 1], 4 * i - 2);
		h[i] = divide(h[i], i + 1);
	}
}

void print(BIGNUM a)
{
	for (int i = a.len - 1; i >= 0; i--)
		printf("%d", a.s[i]);
}


int main()
{
	init();
	int num, casenum = 0;
	while (cin >> num && (num >= 0))
	{
		casenum++;
		printf("%d %d ", casenum, num);
		print(mutiply(h[num], 2));
		printf("\n");
	}
	return 0;
}