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 = , y = , 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 = ;
     while(k)
     {
         if(k&) res *= x;
         x *= x, k >>= ;
     }
     return res;
 }
 typec powerMod(typec x, typec k, typec m)
 {
     typec res = ;
     while(x %= m, k)
     {
         if(k&) res *= x, res %= m;
         x *= x, k >>= ;
     }
     return res;
 }
 typec inverse(typec a, typec p, typec t = )
 {
     typec pt = power(p, t);
     typec x, y;
     y = extendGCD(a, pt, x, y);
     return x < ? 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 < ) x += p * q;
     return x;
 }
 const int PRIMEMAX = ;
 int prime[PRIMEMAX + ];
 int getPrime()
 {
     memset(prime, , sizeof(int) * (PRIMEMAX + ));
     for(int i = ; i <= PRIMEMAX; i++)
     {
         if(!prime[i]) prime[++prime[]] = i;
         for(int j = ; j <= prime[] && prime[j] <= PRIMEMAX/i; j++)
         {
             prime[prime[j]*i] = ;
             if(i % prime[j] == ) break;
         }
     }
     return prime[];
 }
 int factor[][], facCnt;
 int getFactors(int x)
 {
     facCnt = ;
     int tmp = x;
     for(int i = ; prime[i] <= tmp / prime[i]; i++)
     {
         factor[facCnt][] = , factor[facCnt][] = ;
         if(tmp % prime[i] == )
             factor[facCnt][] = prime[i];
         while(tmp % prime[i] == )
             factor[facCnt][]++, factor[facCnt][] *= prime[i], tmp /= prime[i];
         if(factor[facCnt][]) facCnt++;
     }
     if(tmp != ) factor[facCnt][] = tmp, factor[facCnt][] = tmp, factor[facCnt++][] = ;
     return facCnt;
 }
 typec combinationModPt(typec n, typec k, typec p, typec t = )
 {
     if(k > n) return ;
     if(n - k < k) k = n - k;
     typec pt = power(p, t);
     typec a = , b = k + , x, y;
     int pcnt = ;
     while(b % p == ) pcnt--, b /= p;
     b %= pt;
     for(int i = ; i <= k; i++)
     {
         x = n - i + , y = i;
         while(x % p == ) pcnt++, x /= p;
         while(y % p == ) pcnt--, y /= p;
         x %= pt, y %= pt, a *= x, b *= y;
         a %= pt, b %= pt;
     }
     if(pcnt >= t) return ;
     extendGCD(b, pt, x, y);
     if(x < ) x += pt;
     a *= x, a %= pt;
     return a * power(p, pcnt) % pt;
 }
 const typec PTMAX = ;
 typec facmod[PTMAX];
 void initFacMod(typec p, typec t = )
 {
     typec pt = power(p, t);
     facmod[] =  % pt;
     for(int i = ; i < pt; i++)
     {
         if(i % p) facmod[i] = facmod[i - ] * i % pt;
         else facmod[i] = facmod[i - ];
     }
 }
 typec factorialMod(typec n, typec &pcnt, typec p, typec t = )
 {
     typec pt = power(p, t), res = ;
     typec stepCnt = ;
     while(n)
     {
         res *= facmod[n % pt], res %= pt;
         stepCnt += n /pt, n /= p, pcnt += n;
     }
     res *= powerMod(facmod[pt - ], stepCnt, pt);
     return res %= pt;
 }
 typec combinationModPtFac(typec n, typec k, typec p, typec t = )
 {
     if(k > n || p == ) return ;
     if(n - k < k) k = n - k;
     typec pt = power(p, t), pcnt = , pmcnt = ;
     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 <<= , b %= pt;
     typec tmp = k + ;
     while(tmp % p == ) tmp /= p, pmcnt++;
     b *= tmp % pt, b %= pt;
     pcnt -= pmcnt;
     if(pcnt >= t) return ;
     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 = ; i < facCnt; i++)
     {
         if(!i) a = combinationModPtFac(n, k, factor[i][], factor[i][]), p = factor[i][];
         else b = combinationModPtFac(n, k, factor[i][], factor[i][]), q = factor[i][];
         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\n", combinationModFac( * (n-), n-, k));
     return ;
 }