变态组合数C(n,m)求解

转：http://my.oschina.net/baoer1024/blog/62826

（在求卡特兰数时有 一定作用）

问题：求解组合数C(n,m)，即从n个相同物品中取出m个的方案数，由于结果可能非常大，对结果模10007即可。

方案一

暴力求解，C(n,m)=n*(n-1)*...*(n-m+1)/m!

int Combination(int n, int m)

{

const int M = 10007;

int ans = 1;

for(int i=n; i>=(n-m+1); --i)

ans *= i;

while(m)

ans /= m--;

return ans % M;

}

这种方案的缺陷是，在计算过程中很快ans就溢出了，一般情况下，n不能超过12。补救办法之一是将先乘后除改为交叉地进行乘除，先除能整除的，但也只能满足n稍微增大的情况，n最多只能满足两位数。补救办法之二是换用高精度运算，这样结果不会有问题，只是需要实现大数相乘、相除和取模等运算，实现起来比较麻烦，时间复杂度为O(n)。

方案二

打表，C(n,m)=C(n-1,m-1)+C(n-1,m)

由于组合数满足以上性质，可以预先生成所有用到的组合数，使用时，直接查找即可。生成的复杂度为O(n^2)，查询复杂度为O(1)。较方案一而言，支持的数量级大有提升，在1秒内，基本能处理10000以内的组合数。算法的预处理时间较长，另外空间花费较大，都是平方级的，优点是实现简单，查询时间快。

const int M = 10007;

const int MAXN = 1000;

int C[MAXN+1][MAXN+1];

void Initial()

{

int i,j;

for(i=0; i<=MAXN; ++i)

{

C[0][i] = 0;

C[i][0] = 1;

}

for(i=1; i<=MAXN; ++i)

{

for(j=1; j<=MAXN; ++j)

C[i][j] = (C[i-1][j] + C[i-1][j-1]) % M;

}

}

int Combination(int n, int m)

{

return C[n][m];

}

方案三

质因数分解，C(n,m)=n!/(m!*(n-m)!)，设n!分解因式后，质因数p的次数为a；对应地m!分解后p的次数为b；(n-m)!分解后p的次数为c；则C(n,m)分解后，p的次数为a-b-c。计算出所有质因子的次数，它们的积即为答案，即C(n,m)=p1 ^a1-b1-c1p2 ^a2-b2-c2…pk ^ak-bk-ck。n!分解后p的次数为：n/p+n/p ²+…+n/p ^k。

算法的时间复杂度比前两种方案都低，基本上跟n以内的素数个数呈线性关系，而素数个数通常比n都小几个数量级，例如100万以内的素数不到8万个。用筛法生成素数的时间接近线性。该方案1秒钟能计算 1kw数量级的组合数。如果要计算更大，内存和时间消耗都比较大。

//用筛法生成素数

const int MAXN = 1000000;

bool arr[MAXN+1] = {false};

vector<int> produce_prim_number()

{

vector<int> prim;

prim.push_back(2);

int i,j;

for(i=3; i*i<=MAXN; i+=2)

{

if(!arr[i])

{

prim.push_back(i);

for(j=i*i; j<=MAXN; j+=i)

arr[j] = true;

}

}

while(i<=MAXN)

{

if(!arr[i])

prim.push_back(i);

i+=2;

}

return prim;

}

//计算n!中素因子p的指数

int Cal(int x, int p)

{

int ans = 0;

long long rec = p;

while(x>=rec)

{

ans += x/rec;

rec *= p;

}

return ans;

}

//计算n的k次方对M取模，二分法

int Pow(long long n, int k, int M)

{

long long ans = 1;

while(k)

{

if(k&1)

{

ans = (ans * n) % M;

}

n = (n * n) % M;

k >>= 1;

}

return ans;

}

//计算C(n,m)

int Combination(int n, int m)

{

        const int M = 10007;

vector<int> prim = produce_prim_number();

long long ans = 1;

int num;

for(int i=0; i<prim.size() && prim[i]<=n; ++i)

{

num = Cal(n, prim[i]) - Cal(m, prim[i]) - Cal(n-m, prim[i]);

ans = (ans * Pow(prim[i], num, M)) % M;

}

return ans;

}

方案四

Lucas定理，设p是一个素数（题目中要求取模的数也是素数），将n,m均转化为p进制数，表示如下：

满足下式：

  

即C(n,m)模p等于p进制数上各位的C(ni,mi)模p的乘积。利用该定理，可以将计算较大的C(n,m)转化成计算各个较小的C(ni,mi)。

该方案能支持整型范围内所有数的组合数计算，甚至支持64位整数，注意中途溢出处理。该算法的时间复杂度跟n几乎不相关了，可以认为算法复杂度在常数和对数之间。

#include <stdio.h>

const int M = 10007;

int ff[M+5];  //打表，记录n!，避免重复计算

//求最大公因数

int gcd(int a,int b)

{

    if(b==0)

return a;

else

return gcd(b,a%b);

}

//解线性同余方程，扩展欧几里德定理

int x,y;

void Extended_gcd(int a,int b)

{

    if(b==0)

    {

       x=1;

       y=0;

    }

    else

    {

       Extended_gcd(b,a%b);

       long t=x;

       x=y;

       y=t-(a/b)*y;

    }

}

//计算不大的C(n,m)

int C(int a,int b)

{

    if(b>a)

return 0;

    b=(ff[a-b]*ff[b])%M;

    a=ff[a];

    int c=gcd(a,b);

    a/=c;

    b/=c;

    Extended_gcd(b,M);

    x=(x+M)%M;

    x=(x*a)%M;

    return x;

}

//Lucas定理

int Combination(int n, int m)

{

        int ans=1;

int a,b;

while(m||n)

{

        a=n%M;

b=m%M;

n/=M;

m/=M;

ans=(ans*C(a,b))%M;

}

return ans;

}

int main(void)

{

        int i,m,n;

ff[0]=1;

for(i=1;i<=M;i++)  //预计算n!

ff[i]=(ff[i-1]*i)%M;

scanf("%d%d",&n, &m);

printf("%d\n",func(n,m));

return 0;

}

 

方案五：

一个比较有用且是在O（n）时间内实现公式：C(n,r)=(n-r+1)/r*C(n,r-1);

由C(n,0)直接往上推即可；

 

方案六：（一般这种方法在计算机上不能对大数进行实现）

转：http://c.chinaitlab.com/example/805019.html

计算组合数最大的困难在于数据的溢出，对于大于150的整数n求阶乘很容易超出double类型的范围，那么当C(n,m)中的n=200时，直接用组合公式计算基本就无望了。另外一个难点就是效率。

    对于第一个数据溢出的问题，可以这样解决。因为组合数公式为：
    C(n,m) = n!/(m!(n-m)!)

    为了避免直接计算n的阶乘，对公式两边取对数，于是得到：
    ln(C(n,m)) = ln(n!)-ln(m!)-ln((n-m)!)

    进一步化简得到：

   

    这样我们就把连乘转换为了连加，因为ln(n)总是很小的，所以上式很难出现数据溢出。

    为了解决第二个效率的问题，我们对上式再做一步化简。上式已经把连乘法变成了求和的线性运算，也就是说，上式已经极大地简化了计算的复杂度，但是还可以进一步优化。从上式中，我们很容易看出右边的3项必然存在重复的部分。现在我们把右边第一项拆成两部分：

   

    这样，上式右边第一项就可以被抵消掉，于是得到：

   

    上式直接减少了2m次对数计算及求和运算。但是这个公式还可以优化。对于上面公式里的求和，当m<n/2时，n-m是一个很大的数，但是当m>n/2时，n-m就会小很多。我们知道：
    C(n,m) = C(n,n-m)

    那么通过这个公式，我们可以把小于n/2的m变为大于n/2的n-m再进行计算，结果是一样的，但是却能减少计算量。

    当计算出ln(C(n,m))后，只需要取自然对数，就可以得到组合数：
    C(n,m) = exp(ln(C(n,m)))

    这样就完成了组合数的计算。
    用这种方法计算组合数，如果只计算ln(C(n,m))的话，n可以取到整型数据的极限值65535，
    ln(C(65535,32767)) = 45419.6

    而计算时间只需要0.01ms。当然，如果要取对数得到最终的组合数的话，n的取值就不能达到这么大了。但是这种算法仍然可以保证n取到1000以上，而不是开头说的150这个极限值。例如:
    C(1000,500) = 2.70288e+299
    计算时间仍然小于0.01ms。

    采用我这种算法，不仅n的取值范围大，而且计算速度高，不像用递归算法实现这个问题的时候，很容易陷入递归层次太深而导致计算时间太长。

    算法代码实现如下：
     1 double lnchoose(int n, int m)
     2 {
     3     if (m > n)
     4     {
     5         return 0;
     6     }
     7     if (m < n/2.0)
     8     {
     9         m = n-m;
    10     }
    11     double s1 = 0;
    12     for (int i=m+1; i<=n; i++)
    13     {
    14         s1 += log((double)i);
    15     }
    16     double s2 = 0;
    17     int ub = n-m;
    18     for (int i=2; i<=ub; i++)
    19     {
    20         s2 += log((double)i);
    21     }
    22     return s1-s2;
    23 }
    24
    25 double choose(int n, int m)
    26 {
    27     if (m > n)
    28     {
    29         return 0;
    30     }
    31     return exp(lnchoose(n, m));
    32 }