wustoj 1506 药丸（卡特兰数+高精度）

目录

题目：

思路：

AC代码：

---

题目：

1506: 药丸

                                                                             Time Limit: 1 Sec  Memory Limit: 65535 MB   64bit IO Format: %lld

Description

一个药瓶里装有n颗药丸，每天吃半颗，需要在2n天吃完。每天吃药时，从药瓶中取药，如果取到的药是整颗的，就把它分成两半，吃掉其中的一半，另一半重新放入瓶中；如果取到的是半颗药，则直接吃掉。问共有多少种吃药方法？

例如：

n=1，则吃药方法有1种（取一颗，取半颗）。

n=2，则有2种吃药方法（取一颗，取半颗，取一颗，取半颗；取一颗，取一颗，取半颗，取半颗）。

 

Input

有多组测试数据，每组测试数据占一行，每行包含一个整数n（<=100），表示药丸数量。

 

Output

每组测试数据输出占一行，每行包含一个整数，表示吃药方法的种数。

 

Sample Input 

1

2

3

 

Sample Output

1

2

5

思路：

我们可以把取半个和取一个用0和1来代替，这样题目就变成了给出一个n，要求一个长度为2n的01序列，使得序列的任意前缀中1的个数不少于0的个数。

我们可以证明：令1表示进栈，0表示出栈，则可转化为求一个2n位，含n个1，n个0的二进制数， 
满足从左往右扫描到任意一位时，经过的0数不多于1数 
显然含n个1，n个0的2n位二进制数共有个，下面考虑不满足要求的数目. 
考虑一个含n个1，n个0的2n位二进制数，扫描到第2m+1位上时有m+1个0和m个1（容易证明一定存在这样的情况）， 
则后面的01排列中必有n-m个1和n-m-1个0 
将2m+2及其以后的部分0变成1，1变成0，则对应一个n+1个0和n-1个1的二进制数 
反之亦然（相似的思路证明两者一一对应） 
从而，显然这是一个卡特兰数的递推式。

关于卡特兰数的详解

AC代码：

#include<bits/stdc++.h>
using namespace std;
struct BigInteger {
    typedef unsigned long long LL;

    static const int BASE = 100000000;
    static const int WIDTH = 8;
    vector<int> s;

    BigInteger& clean(){while(!s.back()&&s.size()>1)s.pop_back(); return *this;}
    BigInteger(LL num = 0) {*this = num;}
    BigInteger(string s) {*this = s;}
    BigInteger& operator = (long long num) {
        s.clear();
        do {
            s.push_back(num % BASE);
            num /= BASE;
        } while (num > 0);
        return *this;
    }
    BigInteger& operator = (const string& str) {
        s.clear();
        int x, len = (str.length() - 1) / WIDTH + 1;
        for (int i = 0; i < len; i++) {
            int end = str.length() - i*WIDTH;
            int start = max(0, end - WIDTH);
            sscanf(str.substr(start,end-start).c_str(), "%d", &x);
            s.push_back(x);
        }
        return (*this).clean();
    }

    BigInteger operator + (const BigInteger& b) const {
        BigInteger c; c.s.clear();
        for (int i = 0, g = 0; ; i++) {
            if (g == 0 && i >= s.size() && i >= b.s.size()) break;
            int x = g;
            if (i < s.size()) x += s[i];
            if (i < b.s.size()) x += b.s[i];
            c.s.push_back(x % BASE);
            g = x / BASE;
        }
        return c;
    }
    BigInteger operator - (const BigInteger& b) const {
        assert(b <= *this); // 减数不能大于被减数
        BigInteger c; c.s.clear();
        for (int i = 0, g = 0; ; i++) {
            if (g == 0 && i >= s.size() && i >= b.s.size()) break;
            int x = s[i] + g;
            if (i < b.s.size()) x -= b.s[i];
            if (x < 0) {g = -1; x += BASE;} else g = 0;
            c.s.push_back(x);
        }
        return c.clean();
    }
    BigInteger operator * (const BigInteger& b) const {
        int i, j; LL g;
        vector<LL> v(s.size()+b.s.size(), 0);
        BigInteger c; c.s.clear();
        for(i=0;i<s.size();i++) for(j=0;j<b.s.size();j++) v[i+j]+=LL(s[i])*b.s[j];
        for (i = 0, g = 0; ; i++) {
            if (g ==0 && i >= v.size()) break;
            LL x = v[i] + g;
            c.s.push_back(x % BASE);
            g = x / BASE;
        }
        return c.clean();
    }
    BigInteger operator / (const BigInteger& b) const {
        assert(b > 0);  // 除数必须大于0
        BigInteger c = *this;       // 商:主要是让c.s和(*this).s的vector一样大
        BigInteger m;               // 余数:初始化为0
        for (int i = s.size()-1; i >= 0; i--) {
            m = m*BASE + s[i];
            c.s[i] = bsearch(b, m);
            m -= b*c.s[i];
        }
        return c.clean();
    }
    BigInteger operator % (const BigInteger& b) const { //方法与除法相同
        BigInteger c = *this;
        BigInteger m;
        for (int i = s.size()-1; i >= 0; i--) {
            m = m*BASE + s[i];
            c.s[i] = bsearch(b, m);
            m -= b*c.s[i];
        }
        return m;
    }

    int bsearch(const BigInteger& b, const BigInteger& m) const{
        int L = 0, R = BASE-1, x;
        while (1) {
            x = (L+R)>>1;
            if (b*x<=m) {if (b*(x+1)>m) return x; else L = x;}
            else R = x;
        }
    }
    BigInteger& operator += (const BigInteger& b) {*this = *this + b; return *this;}
    BigInteger& operator -= (const BigInteger& b) {*this = *this - b; return *this;}
    BigInteger& operator *= (const BigInteger& b) {*this = *this * b; return *this;}
    BigInteger& operator /= (const BigInteger& b) {*this = *this / b; return *this;}
    BigInteger& operator %= (const BigInteger& b) {*this = *this % b; return *this;}

    bool operator < (const BigInteger& b) const {
        if (s.size() != b.s.size()) return s.size() < b.s.size();
        for (int i = s.size()-1; i >= 0; i--)
            if (s[i] != b.s[i]) return s[i] < b.s[i];
        return false;
    }
    bool operator >(const BigInteger& b) const{return b < *this;}
    bool operator<=(const BigInteger& b) const{return !(b < *this);}
    bool operator>=(const BigInteger& b) const{return !(*this < b);}
    bool operator!=(const BigInteger& b) const{return b < *this || *this < b;}
    bool operator==(const BigInteger& b) const{return !(b < *this) && !(b > *this);}
};

ostream& operator << (ostream& out, const BigInteger& x) {
    out << x.s.back();
    for (int i = x.s.size()-2; i >= 0; i--) {
        char buf[20];
        sprintf(buf, "%08d", x.s[i]);
        for (int j = 0; j < strlen(buf); j++) out << buf[j];
    }
    return out;
}

istream& operator >> (istream& in, BigInteger& x) {
    string s;
    if (!(in >> s)) return in;
    x = s;
    return in;
}

int main()
{
    ios::sync_with_stdio(false);
    BigInteger Catalan[301],ans;
    int n;
    Catalan[0] = 1;
    for(int i = 1;i < 301;++i) Catalan[i] = Catalan[i - 1] * i;
    while(cin >> n){
        ans = Catalan[n << 1] / (Catalan[n] * Catalan[n + 1]);
        cout << ans << endl;
    }
    return 0;
}