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