题解 P2532 【[AHOI2012]树屋阶梯】

本题运用卡特兰数求解。

---

卡特兰数有两种表达方式：

1）\(h_i=\sum^{k=0}_{i-1}h_kh_{i-k-1}\)

2）\(h_i=\frac{1}{n+1}C^{n}_{2n}\)

运用卡特兰数解题的一般步骤是：

1. 证明题目所求的数经过简化/变形后，可以表达为卡特兰数的第一种形式。

2. 通过卡特兰数的第二种形式简化计算。

---

本题乍一看和卡特兰数关系不大。

但是考察之后，发现如下几个特点：

1. 本题所求解的问题是一般性问题。

2. 本题给出的信息其实很少。

因此可以想到用数学方法求解。

而显然本题与递推有关，因此猜测可能与卡特兰数有关。

现在具体说明如何求解。

对于大小为i的阶梯，我们可以把它拆成简单的情况。

比如放一个k大的阶梯，那么剩下的用i-k-1就可以了。

也就是\(f_i=\sum^{k=0}_{i-1}f_kf_{i-k-1}\)。

符合第一种形态。

因此套第二种就可以了。

需要注意的是这道题要打一个高精，这里贡献一个板子：

    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;
    }

转载于:https://www.cnblogs.com/ilverene/p/9850606.html