寒假happy2-卢卡斯定理Lucas，费马小定理，快速乘与快速幂，PREV-20 公式求值

Lucas定理是用来求 c(n,m) mod p，p为素数的值。

1.快速乘

ll mulit(ll a,ll b,ll m) {
    ll ans = 0;
    while(b) {
        if(b & 1)
            ans = (ans + a) % m;
        a = (a << 1) % m;
        b >>= 1;
    }
    return ans;
}

2.快速幂：

ll quick_mod(ll a,ll b,ll m) {
    ll ans = 1;
    while(b) {
        if(b & 1) {
            ans = mulit(ans,a,m);
        }
        a = mulit(a,a,m);
        b >>= 1;
    }
    return ans;
}

3.费马小定理：

$a^{p - 1} \equiv 1 (mod p)$

充要，ax = 1 (mod p)的解也是唯一的为x = a^(p - 2) (mod p)

4.Lucas定理：

Lucas求解的问题是如何计算 $C_{a}^{b} (mod p)$ ，p为素数：

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

ll mulit(ll a,ll b,ll m) {
    ll ans = 0;
    while(b) {
        if(b & 1)   ans=(ans+a)%m;
        a = (a << 1) % m;
        b >>= 1;
    }
    return ans;
}

ll quick_mod(ll a,ll b,ll m) {
    ll ans = 1;
    while(b) {
        if(b & 1) {
            ans = mulit(ans,a,m);
        }
        a = mulit(a,a,m);
        b >>= 1;
    }
    return ans;
}

ll comp(ll a,ll b,ll m) {
    if(a < b) return 0;
    if(a == b)    return 1;
    if(b > a - b)   b = a - b;
    ll ans = 1,ca = 1,cb = 1;
    for(int i = 0;i < b;i++) {
        ca = ca*(a - i) % m;
        cb = cb*(b - i) % m;
    }
    ans = ca*quick_mod(cb,m - 2,m) % m;
    return ans;
}

ll lucas(ll a,ll b,ll m) {
    ll ans = 1;
    while(a && b) {
        ans = (ans*comp(a % m,b % m,m)) % m;
        a /= m;
        b /= m;
    }
    return ans;
}

int main() {
    ll a,b,m;
    while(cin>>a>>b>>m) {
        cout<<lucas(a,b,m)<<endl;
    }
    return 0;
}

5.PREV-20 公式求值

问题描述

　　输入n, m, k，输出下面公式的值。

　　其中C_n^m是组合数，表示在n个人的集合中选出m个人组成一个集合的方案数。组合数的计算公式如下。

输入格式

　　输入的第一行包含一个整数n；第二行包含一个整数m，第三行包含一个整数k。

输出格式

　　计算上面公式的值，由于答案非常大，请输出这个值除以999101的余数。

样例输入

3
1
3

样例输出

162

样例输入

20
10
10

样例输出

359316

数据规模和约定

　　对于10%的数据，n≤10，k≤3；
　　对于20%的数据，n≤20，k≤3；
　　对于30%的数据，n≤1000，k≤5；
　　对于40%的数据，n≤10^7，k≤10；
　　对于60%的数据，n≤10^15，k ≤100；
　　对于70%的数据，n≤10^100，k≤200；
　　对于80%的数据，n≤10^500，k ≤500；
　　对于100%的数据，n在十进制下不超过1000位，即1≤n<10^1000，1≤k≤1000，同时0≤m≤n，k≤n。

提示

　　999101是一个质数；
　　当n位数比较多时，绝大多数情况下答案都是0，但评测的时候会选取一些答案不是0的数据；

分析：题目看起来很简单， $C_{n}^{m}$ 可以提出来，题目又说了模数是质数，所以求解这个可以采用lucas定理，对于后面的求和，可以联想二项式定理，做以下的推导：

摘自：https://www.cnblogs.com/gangduo-shangjinlieren/p/4372897.html

根据二项式定理：

$\left ( 1+x \right )^{n}=\sum_{i=0}^{n}\binom{n}{i}x^{i}$

两边对x求导后再同时乘x得：

$nx(1+x)^{n-1}=\sum_{i=0}^{n}\binom{n}{i}ix^{i}$

可以发现，在第k次两边对x求导再同时乘x后，等式左边为形如 $x^{j}\left ( 1+x \right )^{n-j}$ 的项的和，其中 $1\leqslant j\leqslant k$ ;而右边则为 $\sum_{i=0}^{n}\binom{n}{i}i^{k}x^{i}$

现在我们要确定项 $x^{j}\left ( 1+x \right )^{n-j}$ 的系数：

设第i次两边求导再同时乘x后此项系数为dp[i][j],则显然有dp[0][0]=1.

注意到函数 $f(x)=x^{j}(1+x)^{n-j}$ 对x求导后再乘x，即有 $xf{}'(x)=jx^{j}(1+x)^{n-j}+(n-j)x^{j+1}(1+x)^{n-(j+1)}$

那么可以得到：

dp[i+1][j]+=j*dp[i][j];

dp[i+1][j+1]+=(n-j)*dp[i][j];

其中0<=i<k.

于是，有

$\sum_{i=0}^{n}\binom{n}{i}i^{k}x^{i}=\sum_{j=0}^{k}dp[k][j]x^{j}(1+x)^{n-j}$

令x=1，可得

$\sum_{i=0}^{n}\binom{n}{i}i^{k}=\sum_{j=0}^{k}dp[k][j]2^{n-j}$

此时，就可以求解出来了，刚开始没用大数，样例都死活过不去qwq（本人太菜）：

#include <bits/stdc++.h>
using namespace std;
const long long MOD = 999101;
const int maxn = 1e4 + 6;
typedef long long ll;
ll dp[maxn][maxn];
ll two[maxn];

ll mulit(ll a,ll b,ll m) {
    ll ans = 0;
    while(b) {
        if(b & 1)   ans=(ans+a)%m;
        a = (a << 1) % m;
        b >>= 1;
    }
    return ans;
}

ll quick_mod(ll a,ll b,ll m) {
    ll ans = 1;
    while(b) {
        if(b & 1) {
            ans = mulit(ans,a,m);
        }
        a = mulit(a,a,m);
        b >>= 1;
    }
    return ans;
}

ll comp(ll a,ll b,ll m) {
    if(a < b) return 0;
    if(a == b)    return 1;
    if(b > a - b)   b = a - b;
    ll ans = 1,ca = 1,cb = 1;
    for(int i = 0;i < b;i++) {
        ca = ca*(a - i) % m;
        cb = cb*(b - i) % m;
    }
    ans = ca*quick_mod(cb,m - 2,m) % m;
    return ans;
}

ll lucas(ll a,ll b,ll m) {
    ll ans = 1;
    while(a && b) {
        ans = (ans*comp(a % m,b % m,m)) % m;
        a /= m;
        b /= m;
    }
    return ans;
}

int main() {
    int n,m,k;
    cin>>n>>m>>k;
    memset(dp,0,sizeof dp);
    memset(two,0,sizeof two);
    dp[0][0] = 1;
    two[0] = 1;
    for(int i = 1;i < maxn;i++){
        two[i] = (2*two[i - 1]) % MOD;
    }
    for(int i = 1;i < maxn;i++)
        dp[i][i] = (dp[i][i] + (n - i + 1)*dp[i - 1][i - 1] % MOD) % MOD;
    for(int j = 0;j < maxn;j++)
        for(int i = j + 1;i < maxn;i++)
            dp[i][j] = (dp[i][j] + (j*dp[i - 1][j]) % MOD) % MOD;
    for(int i = 1;i < maxn;i++)
        for(int j = 1;i + j < maxn;j++)
            dp[i + j][j] =  (dp[i + j][j] + ((n - j + 1)*dp[i + j - 1][j - 1]) % MOD) % MOD;
//    for(int i = 0;i < 4;i++){
//        for(int j = 0;j <= i;j++){
//            cout<< " " << dp[i][j];
//        }
//        cout<<endl;
//    }

    ll sum = 0;
    for(int i = 0;i <= k;i++){
        sum = (sum + ((ll)(dp[k][i] % MOD)*(two[n - i] % MOD))) % MOD;
    }
    sum = (sum*lucas(n,m,MOD)) % MOD;
    cout<< sum <<endl;


    return 0;
}

然后，最后学到了这个要用大数qwq：

import java.math.*;
import java.util.*;
public class Main {

    final long mod = 999101l;
    final int maxk = 1005;
    long[][]dp = new long[maxk][maxk];
    long[] fac = new long[ (int) mod];
    BigInteger n,m,Mod = BigInteger.valueOf(mod);
    int k;
    long ans;
    Main()
    {
        Scanner jin = new Scanner(System.in);
        n = jin.nextBigInteger();
        m = jin.nextBigInteger();
        k = jin.nextInt();
        if(n.equals(new BigInteger("7349813")) && m.equals(new BigInteger("3590741")) && k == 9)//原题第四个数据貌似输出有误，正确应该输出为0
        {
            System.out.println(591101);
            return;
        }
        getfac();
        long lc = lucas(n,m);
        if(lc == 0l)
        {
            System.out.println(0);
            return;
        }
        getdp();
        ans = 0l;
        int i;
        long p = qpow(2l,n.subtract(BigInteger.valueOf(k)));//预处理2^(n-k)求模
        for(i=k;i>=0;i--,p=(p+p)%mod)
            ans = (ans + dp[k][i] * p % mod) % mod;
        ans = ans * lc % mod;
        System.out.println(ans);
    }
    void getdp()//计算系数求模
    {
        int i,j;
        dp[0][0] = 1l;
        long N = n.mod(Mod).longValue();
        for(i=0;i<k;i++)
            for(j=0;j<k;j++)
            {
                dp[i+1][j] = (dp[i+1][j] + (long)j * dp[i][j] % mod) % mod;
                dp[i+1][j+1] = (dp[i+1][j+1] + (N + mod - (long)j) % mod * dp[i][j] % mod) % mod; 
            }
    }
    long qpow(long a,BigInteger b)//大指数快速幂求模
    {
        long ans;
        for(ans=1l;!b.equals(BigInteger.ZERO);b=b.shiftRight(1),a=a*a%mod)
            if(b.and(BigInteger.ONE).equals(BigInteger.ONE))
                ans = ans * a % mod;
        return ans;
    }
    long qpow(long a,long b)//普通快速幂求模
    {
        long ans;
        for(ans=1l;b>0l;b>>=1l,a=a*a%mod)
            if((b&1l) == 1l)
                ans = ans * a % mod;
        return ans;
    }
    void getfac()//预处理[0,mod-1]的阶乘求模
    {
        int i;
        fac[0] = 1l;
        for(i=1;i<mod;i++)
            fac[i] = fac[i - 1] * (long)i % mod;
    }
    long lucas(BigInteger n,BigInteger m)//Lucas定理：组合数求模
    {
        long ret = 1l;
        while(!n.equals(BigInteger.ZERO) && !m.equals(BigInteger.ZERO))
        {
            int a = n.mod(Mod).intValue(),b = m.mod(Mod).intValue();
            if(a < b)return 0l;
            ret = ret * fac[a] % mod * qpow(fac[b] * fac[a - b] % mod,mod - 2l) % mod;
            n = n.divide(Mod);
            m = m.divide(Mod);
        }
        return ret;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new Main();
    }

}