HUNAN 11562 The Triangle Division of the Convex Polygon(大卡特兰数)

http://acm.hunnu.edu.cn/online/?action=problem&type=show&id=11562&courseid=0

求n边形分解成三角形的方案数。

就是求n-2个卡特兰数,从大神那盗取了一份模板,效率极高.同时也很复杂.

#include <cstdio>
#include <cmath>
#include <stdlib.h>
#include <memory.h>
typedef int typec;
typec GCD(typec a, typec b)
{
    return b? GCD(b, a % b) : a;
}
typec extendGCD(typec a, typec b, typec& x, typec& y)
{
    if(!b) return x = 1, y = 0, a;
    typec res = extendGCD(b, a % b, x, y), tmp = x;
    x = y, y = tmp -(a/b)*y;
    return res;
}
typec power(typec x, typec k)
{
    typec res = 1;
    while(k)
    {
        if(k&1) res *= x;
        x *= x, k >>= 1;
    }
    return res;
}
typec powerMod(typec x, typec k, typec m)
{
    typec res = 1;
    while(x %= m, k)
    {
        if(k&1) res *= x, res %= m;
        x *= x, k >>= 1;
    }
    return res;
}
typec inverse(typec a, typec p, typec t = 1)
{
    typec pt = power(p, t);
    typec x, y;
    y = extendGCD(a, pt, x, y);
    return x < 0? x += pt : x;
}
typec linearCongruence(typec a, typec b, typec p, typec q)
{
    typec x, y;
    y = extendGCD(p, q, x, y);
    x *= b - a, x = p * x + a, x %= p * q;
    if(x < 0) x += p * q;
    return x;
}
const int PRIMEMAX = 1000;
int prime[PRIMEMAX + 1];
int getPrime()
{
    memset(prime, 0, sizeof(int) * (PRIMEMAX + 1));
    for(int i = 2; i <= PRIMEMAX; i++)
    {
        if(!prime[i]) prime[++prime[0]] = i;
        for(int j = 1; j <= prime[0] && prime[j] <= PRIMEMAX/i; j++)
        {
            prime[prime[j]*i] = 1;
            if(i % prime[j] == 0) break;
        }
    }
    return prime[0];
}
int factor[100][3], facCnt;
int getFactors(int x)
{
    facCnt = 0;
    int tmp = x;
    for(int i = 1; prime[i] <= tmp / prime[i]; i++)
    {
        factor[facCnt][1] = 1, factor[facCnt][2] = 0;
        if(tmp % prime[i] == 0)
            factor[facCnt][0] = prime[i];
        while(tmp % prime[i] == 0)
            factor[facCnt][2]++, factor[facCnt][1] *= prime[i], tmp /= prime[i];
        if(factor[facCnt][2]) facCnt++;
    }
    if(tmp != 1) factor[facCnt][0] = tmp, factor[facCnt][1] = tmp, factor[facCnt++][2] = 1;
    return facCnt;
}
typec combinationModPt(typec n, typec k, typec p, typec t = 1)
{
    if(k > n) return 0;
    if(n - k < k) k = n - k;
    typec pt = power(p, t);
    typec a = 1, b = k + 1, x, y;
    int pcnt = 0;
    while(b % p == 0) pcnt--, b /= p;
    b %= pt;
    for(int i = 1; i <= k; i++)
    {
        x = n - i + 1, y = i;
        while(x % p == 0) pcnt++, x /= p;
        while(y % p == 0) pcnt--, y /= p;
        x %= pt, y %= pt, a *= x, b *= y;
        a %= pt, b %= pt;
    }
    if(pcnt >= t) return 0;
    extendGCD(b, pt, x, y);
    if(x < 0) x += pt;
    a *= x, a %= pt;
    return a * power(p, pcnt) % pt;
}
const typec PTMAX = 45000;
typec facmod[PTMAX];
void initFacMod(typec p, typec t = 1)
{
    typec pt = power(p, t);
    facmod[0] = 1 % pt;
    for(int i = 1; i < pt; i++)
    {
        if(i % p) facmod[i] = facmod[i - 1] * i % pt;
        else facmod[i] = facmod[i - 1];
    }
}
typec factorialMod(typec n, typec &pcnt, typec p, typec t = 1)
{
    typec pt = power(p, t), res = 1;
    typec stepCnt = 0;
    while(n)
    {
        res *= facmod[n % pt], res %= pt;
        stepCnt += n /pt, n /= p, pcnt += n;
    }
    res *= powerMod(facmod[pt - 1], stepCnt, pt);
    return res %= pt;
}
typec combinationModPtFac(typec n, typec k, typec p, typec t = 1)
{
    if(k > n || p == 1) return 0;
    if(n - k < k) k = n - k;
    typec pt = power(p, t), pcnt = 0, pmcnt = 0;
    if(k < pt) return combinationModPt(n, k, p, t);
    initFacMod(p, t);
    typec a = factorialMod(n, pcnt, p, t);
    typec b = factorialMod(k, pmcnt, p, t);
    b *= b, pmcnt <<= 1, b %= pt;
    typec tmp = k + 1;
    while(tmp % p == 0) tmp /= p, pmcnt++;
    b *= tmp % pt, b %= pt;
    pcnt -= pmcnt;
    if(pcnt >= t) return 0;
    a *= inverse(b, p, t), a %= pt;
    return a * power(p, pcnt) % pt;
}
typec combinationModFac(typec n, typec k, typec m)
{
    getFactors(m);
    typec a, b, p, q;
    for(int i = 0; i < facCnt; i++)
    {
        if(!i) a = combinationModPtFac(n, k, factor[i][0], factor[i][2]), p = factor[i][1];
        else b = combinationModPtFac(n, k, factor[i][0], factor[i][2]), q = factor[i][1];
        if(!i) continue;
        a = linearCongruence(a, b, p, q), p *= q;
    }
    return a;
}
int main()
{
    getPrime();
    typec n, k;
    while(scanf("%d %d", &n, &k) != EOF)
        printf("%d
", combinationModFac(2 * (n-2), n-2, k));
    return 0;
}