hdu 1134 Game of Connections 【卡特兰数+大数】

Game of Connections

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 3327    Accepted Submission(s): 1896

Problem Description

This is a small but ancient game. You are supposed to write down the numbers 1, 2, 3, ... , 2n - 1, 2n consecutively in clockwise order on the ground to form a circle, and then, to draw some straight line segments to connect them into number pairs. Every number
must be connected to exactly one another. And, no two segments are allowed to intersect.

It‘s still a simple game, isn‘t it? But after you‘ve written down the 2n numbers, can you tell me in how many different ways can you connect the numbers into pairs? Life is harder, right?

Input

Each line of the input file will be a single positive number n, except the last line, which is a number -1. You may assume that 1 <= n <= 100.

Output

For each n, print in a single line the number of ways to connect the 2n numbers into pairs.

Sample Input

2
3
-1

Sample Output

2
5

Source

Asia 2004, Shanghai (Mainland China), Preliminary

#include <stdio.h>
#include <iostream>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <ctype.h>
#include <time.h>
#include <queue>
#include <iterator>

using namespace std;

#define MAXN 9999
#define MAXSIZE 1010
#define DLEN 4

class BigNum
{
private:
	int a[1000];  //可以控制大数的位数
	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[t1.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 p[3010];

int main()
{
	int i, n;
	p[0] = 1;
	for (int i = 1; i<= 100; i++)
		p[i] = p[i - 1] * (4 * i - 2) / (i + 1);

	while (cin>>n && n!=-1)
	{
		p[n].print();
	}
	return 0;
}
时间： 2024-10-11 10:17:23

hdu 1134 Game of Connections 【卡特兰数+大数】的相关文章

HDU Train Problem II （卡特兰数+大数）

Problem Description As we all know the Train Problem I, the boss of the Ignatius Train Station want to know if all the trains come in strict-increasing order, how many orders that all the trains can get out of the railway.   Input The input contains

2014年百度之星程序设计大赛 - 初赛（第一轮） hdu Grids (卡特兰数 大数除法取余 扩展gcd)

题目链接 分析:打表以后就能发现时卡特兰数, 但是有除法取余. f[i] = f[i-1]*(4*i - 2)/(i+1); 看了一下网上的题解,照着题解写了下面的代码,不过还是不明白,为什么用扩展gcd, 不是用逆元吗.. 网上还有别人的解释,没看懂,贴一下: (a / b) % m = ( a % (m*b)) / b 笔者注:鉴于ACM题目特别喜欢M=1000000007,为质数: 当gcd(b,m) = 1, 有性质: (a/b)%m = (a*b^-1)%m, 其中b^-1是b模m的逆

hdu 5177 (1e18范围的卡特兰数)

hdu 5177 (1e18范围的卡特兰数) 题意: 求第n个卡特兰数,模3814697265625 (5^18) 限制: 有20组数据,1 <= n <= 1e18 思路: 1. 卡特兰数的表达式: ans = 1/(n+1) * C(2*n,n) -> ans = 1/(n+1) * (2n)! / n! / n!    ---1式 2. 因为要模5^18,求逆元要求互质,所以先把"1式"中的因子5全部去掉 3. 然后看不含因子5的阶乘,f(n!) 4. 设g(x

HDU 1134 Game of Connections（卡特兰数）

题目代号:HDU 1134 题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=1134 Game of Connections Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 4668    Accepted Submission(s): 2729 Problem Description Thi

HDOJ/HDU 1133 Buy the Ticket(数论~卡特兰数~大数~)

Problem Description The "Harry Potter and the Goblet of Fire" will be on show in the next few days. As a crazy fan of Harry Potter, you will go to the cinema and have the first sight, won't you? Suppose the cinema only has one ticket-office and

hdu 1130(卡特兰数,大数)

How Many Trees? Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)Total Submission(s): 3382    Accepted Submission(s): 1960 Problem Description A binary search tree is a binary tree with root k such that any node v re

卡特兰数大数相乘

计算1-100卡特兰数,必须要用数组存,大数模板 注:卡特兰数:卡特兰数又称卡塔兰数,是组合数学中一个常出现在各种计数问题中出现的数列.由以比利时的数学家欧仁·查理·卡塔兰 (1814–1894)命名.原理: 令h(1)＝1,h(0)=1,catalan数满足递归式: h(n)= h(0)*h(n-1)+h(1)*h(n-2) + ... + h(n-1)h(0) (其中n>=2) 另类递归式: h(n)=((4*n-2)/(n+1))*h(n-1); 该递推关系的解为: h(n)=C(2n,n

POJ2084 Game of Connections 卡特兰数 关于卡特兰数经典的几个问题

Game of Connections Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 9128   Accepted: 4471 Description This is a small but ancient game. You are supposed to write down the numbers 1, 2, 3, . . . , 2n - 1, 2n consecutively in clockwise ord

HDU 1023 Train Problem II (卡特兰数，经典)

题意:给出一个数字n,假设火车从1~n的顺序分别进站,求有多少种出站序列. 思路:卡特兰数的经典例子.n<101,用递推式解决.需要使用到大数.n=100时大概有200位以下. 1 #include <bits/stdc++.h> 2 using namespace std; 3 const int N=101; 4 vector<string> vect; 5 void _mult(string num1, string num2, string &result )

B - Game of Connections(卡特兰数)

This is a small but ancient game. You are supposed to write down the numbers 1, 2, 3, ... , 2n - 1, 2n consecutively in clockwise order on the ground to form a circle, and then, to draw some straight line segments to connect them into number pairs. E