Question

This problem的答案结果是使用Lucas' theorem计算模数为素数的二项式系数。以下是使用此技术解决该问题的方法：here。

现在我的问题是：

如果数据因变量溢出而增加，似乎我的代码会过期。有办法解决这个问题吗？
有没有办法在不使用此theorem的情况下执行此操作？

编辑：请注意，由于这是 OI或ACM 问题，因此不允许使用除原始版本之外的其他库。

以下代码：

#include <iostream>
#include <string.h>
#include <stdio.h>
using namespace std;

#define N 100010

long long mod_pow(int a,int n,int p)
{
    long long ret=1;
    long long A=a;
    while(n)
    {
        if (n & 1)
            ret=(ret*A)%p;
        A=(A*A)%p;
        n>>=1;
    }
    return ret;
}

long long factorial[N];

void init(long long p)
{
    factorial[0] = 1;
    for(int i = 1;i <= p;i++)
        factorial[i] = factorial[i-1]*i%p;
    //for(int i = 0;i < p;i++)
        //ni[i] = mod_pow(factorial[i],p-2,p);
}

long long Lucas(long long a,long long k,long long p) 
{
    long long re = 1;
    while(a && k)
    {
        long long aa = a%p;long long bb = k%p;
        if(aa < bb) return 0; 
        re = re*factorial[aa]*mod_pow(factorial[bb]*factorial[aa-bb]%p,p-2,p)%p;
        a /= p;
        k /= p;
    }
    return re;
}

int main()
{
    int t;
    cin >> t;
    while(t--)
    {
        long long n,m,p;
        cin >> n >> m >> p;
        init(p);
        cout << Lucas(n+m,m,p) << "\n";
    }
    return 0;
}

Answer 1

此解决方案假设 p ²符合unsigned long long。由于unsigned long long按标准至少有64位，因此至少对于 p 最多可达40亿，远远超过问题所指定的范围。

typedef unsigned long long num;

/* x such that a*x = 1 mod p */
num modinv(num a, num p)
{
    /* implement this one on your own */
    /* you can use the extended Euclidean algorithm */
}

/* n chose m mod p */
/* computed with the theorem of Lucas */
num modbinom(num n, num m, num p)
{
    num i, result, divisor, n_, m_;

    if (m == 0)
        return 1;

    /* check for the likely case that the result is zero */
    if (n < m)
        return 0;

    for (n_ = n, m_ = m; m_ > 0; n_ /= p, m_ /= p)
        if (n_ % p < m_ % p)
            return 0;

    for (result = 1; n >= p || m >= p; n /= p, m /= p) {
        result *= modbinom(n % p, m % p, p);
        result %= p;
    }

    /* avoid unnecessary computations */
    if (m > n - m)
         m = n - m;

    divisor = 1;
    for (i = 0; i < m; i++) {
         result *= n - i;
         result %= p;

         divisor *= i + 1;
         divisor %= p;
    }

    result *= modinv(divisor, p);
    result %= p;

    return result;
}

Answer 2

无限精度整数似乎是要走的路。

如果您使用的是C ++， PicklingTools库有一个“无限精度”整数（类似于 Python的LONG类型）。其他人建议使用Python，这是合理的如果你了解Python就回答。如果你想用C ++做，你可以使用int_n类型：

#include "ocval.h"
int_n n="012345678910227836478627843";
n = n + 1;   // Can combine with other plain ints as well

请查看以下文档：

3

和

http://www.picklingtools.com/html/usersguide.html#c-int-n-and-the-python-arbitrary-size-ints-long

C ++ PicklingTools的下载是http://www.picklingtools.com/html/faq.html#c-and-otab-tup-int-un-int-n-new-in-picklingtools-1-2-0。

Answer 3

您需要bignum（a.k.a。任意精度算术）库。

首先，不要编写自己的bignum（或bigint）库，因为有效的算法（比你在学校学到的那些非常有效）很难设计和实现。

然后，我会推荐GMPlib。它是免费的软件，文档齐全，经常使用，效率很高，设计精良（可能存在一些不完善之处，特别是无法插入自己的内存分配器来代替系统malloc;但你可能不会护理，除非你想抓住罕见的内存不足的情况......）。它很简单C++ interface。它包装在大多数Linux发行版中。

如果是家庭作业，也许你的老师希望你更多地考虑数学，并找到一种解决问题的方法没有任何bignums。

Answer 4

让我们假设我们需要计算(a / b) mod p的值，其中p是素数。由于p是素数，因此每个数字b都有一个反模p。所以(a / b) mod p = (a mod p) * (b mod p)^-1。我们可以使用欧几里得算法来计算逆。

要获得(n over k)，我们需要计算n! mod p，(k!)^-1，((n - k)!)^-1。总时间复杂度为O(n)。

更新：以下是c ++中的代码。我没有广泛测试它。

int64_t fastPow(int64_t a, int64_t exp, int64_t mod)                               
{                                                                                  
    int64_t res = 1;                                                               
    while (exp)                                                                    
    {                                                                              
        if (exp % 2 == 1)                                                          
        {                                                                          
            res *= a;                                                              
            res %= mod;                                                            
        }                                                                          

        a *= a;                                                                    
        a %= mod;                                                                  
        exp >>= 1;                                                                 
    }                                                                              
    return res;                                                                    
}                                                                                  

// This inverse works only for primes p, it uses Fermat's little theorem                                                                                   
int64_t inverse(int64_t a, int64_t p)                                              
{                                                                                  
    assert(p >= 2);                                                                
    return fastPow(a, p - 2, p);                                                   
}                                                                                  

int64_t binomial(int64_t n, int64_t k, int64_t p)                                  
{                                                                                  
    std::vector<int64_t> fact(n + 1);                                              
    fact[0] = 1;                                                                   
    for (auto i = 1; i <= n; ++i)                                                  
        fact[i] = (fact[i - 1] * i) % p;                                           

    return ((((fact[n] * inverse(fact[k], p)) % p) * inverse(fact[n - k], p)) % p);
}

如何用素数计算极大的二项式系数？

4 个答案: