Poj 2084 Game of Connections 卡特兰数高精度-优快云博客

本文介绍了一个古老的游戏，通过连接圆周上的数字来形成配对，要求不出现交叉线段。文章分析了问题背后的数学原理，即卡特兰数，并提供了使用高精度计算求解卡特兰数的C++代码实现。

Poj 2084 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. 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

分析：找规律发现通项是卡特兰数

由于n<=100所以这里会爆long long 要用到高精度

卡塔兰数的一般项公式为$ {\displaystyle 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的另一个表达形式为${\displaystyle C_{n}={2n \choose n}-{2n \choose n+1}\quad {\mbox{ for }}n\geq 1} $

代码如下

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
using namespace std;
#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);
        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;
        int operator%(const int &) const;
        bool operator>(const BigNum &T) const;
        bool operator>(const int &t) const;
        void print();
};
BigNum::BigNum(const int b) {
    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(int 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) {
    int i = -1;
    char ch[MAXSIZE*4];
    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] = -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 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{
    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 {
    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;
}

转载于:https://www.cnblogs.com/pot-a-to/p/10975485.html