hdu3240 Counting Binary Trees 卡特兰数 乘法逆元

Counting Binary Trees

Time Limit: 6000/3000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 493 Accepted Submission(s): 151

Problem Description

There are 5 distinct binary trees of 3 nodes:

Let T(n) be the number of distinct non-empty binary trees of no more than n nodes, your task is to calculate T(n) mod m.

Input

The input contains at most 10 test cases. Each case contains two integers n and m (1 <= n <= 100,000, 1 <= m <= 10 ⁹) on a single line. The input ends with n = m = 0.

Output

For each test case, print T(n) mod m.

Sample Input

   
   
   
   

    
    
    
    3 100
4 10
0 0
   
   
   
   

Sample Output

   
   
   
   

    
    
    
    8
2
   
   
   
   

Source

2009 “NIT Cup” National Invitational Contest

Recommend

zhonglihua

题意要求，小于等于n个结点的二叉树的个数，我们知道，每个二叉树的个数是卡特兰数，所以答案就是前n个卡特兰数之和。

比如 a * b % m = 1,则称a 和b 是互为在模m下的乘法逆元。当a的逆存在时，除a,就相当于乘上a的逆。但是一个数逆是不一定存在的，如果n是素数的话，那就是一定存在的。

这时可以用欧拉定理求，a^(f(m)) = 1(mod m);f(m) = m-1;当m为素数时。也就是说a的逆就为 a^(m-2);f(n)就是欧拉函数，等于不超过x且和x互素的个数。利用与筛选法类似的方法可以求出所有的欧拉表。代码为

//计算欧拉函数phi(1),phi(2),..phi(n)
int phi[N];
void phi_table(int n){
    for(int i = 2;i<=n;i++) phi[i] = 0;
    phi[1] = 1;
    for(int i = 2;i<=n;i++)
        if(!phi[i]){
            for(int j = i;j<=n;j+=i){
                if(!phi[j]) phi[j] = j;
                phi[j] = phi[j] / i * (i - 1);
            }
        }
}

另外一种方法求逆是用欧几里得算法，给出完整代码

void gcd(ll a,ll b,ll& d,ll& x,ll& y){
    if(!b){d = a;x= 1;y = 0;}
    else  {gcd(b,a%b,d,y,x);y -= x* (a/b);}
}
//计算模n下a的逆，不存在返回 -1
ll inv(ll a,ll n){
    ll d ,x,y;
    gcd(a,n,d,x,y);
    return d == 1? (x + n) % n:-1;
}

卡特兰数可以由公式，h[i]=h[i-1]*(4*i-2)/(i+1)得出，但是，我们知道，由于，是取过模的，我们如果，不还是直接除的话，是不对的，所以，我们要用乘法逆元就可以了，但是，乘法逆元，要求是互质的数， 这里，我们，把m的质因子保存下来，互素的直接算就可以了 ！也就是说，这题的m不一定是素数，所以我们首先要先求出m的所有素因子。第二步：把 4 * i - 2 的素因子，全部计数，装入相应的计数器，都加1，把k - 1的素因子，都在相应的计数器中减1，这样是为了保证k-1得到的最后的数是和m互质的。这样的话除上k 就可乘上相应的逆。第三步，用res记录除质因子外的相乘模后的数，再和所有的素因子相乘取模就是答案了。

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
__int64 vec[40],num[40],m,index;

__int64 ectgcd(__int64 a,__int64 b,__int64 & x,__int64 & y)
{
    if(b==0){x=1;y=0;return a;}
    __int64 d=ectgcd(b,a%b,x,y);
    __int64 t=x;x=y;y=(t-a/b*y);
    return d;
}
int main()
{
   __int64 i,j,tempm,t,k,l;
   __int64 n;
   while(scanf("%I64d%I64d",&n,&m)!=EOF&&n+m)
   {
       memset(num,0,sizeof(num));
       index=0;
       tempm=m;
       for(i=2;i*i<=m;i++)
       {
          if(m%i==0)
          {
              vec[index++]=i;
              while(m%i==0)
              {
                  m=m/i;
              }
          }
       }
       if(m!=1)
       vec[index++]=m;
       m=tempm;
       __int64 res=1,result=0;
       for(i=1;i<=n;i++)
       {
           k=4*i-2;
            for(j=0;j<index;j++)
            {
                if(k%vec[j]==0)
                {
                    while(k%vec[j]==0)
                    {
                        k=k/vec[j];
                        num[j]++;
                    }
                }
            }
            res=res*k%m;
            k=i+1;
            for(j=0;j<index;j++)
            {
                if(k%vec[j]==0)
                {
                    while(k%vec[j]==0)
                    {
                        k=k/vec[j];
                        num[j]--;
                    }
                }
            }
            if(k!=1)
            {
                __int64 x,y;
               ectgcd(k,m,x,y);
                x=x%m;
                if(x<0)
                x+=m;
                res=res*x%m;
            }
            l=res;
            for(j=0;j<index;j++)
                for(t=0;t<num[j];t++)
                l=l*vec[j]%m;
          result=(result+l)%m;
       }
       printf("%I64d\n",result);
   }
    return 0;
}