藍橋杯-歷屆試題-公式求值

歷屆試題 公式求值

時間限制：1.0s   內存限制：256.0MB

 

問題描述

　　輸入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的數據；

 

解題思路：

參考  http://tieba.baidu.com/p/2832505865 14樓的解題分析，特此感謝@quailty

根據二項式定理：

兩邊對x求導后再同時乘x得：

可以發現，在第k次兩邊對x求導再同時乘x后，等式左邊為形如 的項的和，其中 ;而右邊則為

現在我們要確定項 的系數：

設第i次兩邊求導再同時乘x后此項系數為dp[i][j],則顯然有dp[0][0]=1.

注意到函數 對x求導后再乘x，即有

那么可以得到：

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

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

其中0<=i<k.

於是，有

令x=1，可得

題目中原式可提取 ，從而變形為

其中 對質數求模可以考慮用 Lucas定理計算.

 

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();
    }

}