Unknown Treasure(hdu5446)

Unknown Treasure

Time Limit: 1500/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 2112    Accepted Submission(s): 771

Problem Description

On the way to the next secret treasure hiding place, the mathematician discovered a cave unknown to the map. The mathematician entered the cave because it is there. Somewhere deep in the cave, she found a treasure chest with a combination lock and some numbers on it. After quite a research, the mathematician found out that the correct combination to the lock would be obtained by calculating how many ways are there to pick m different apples among n of them and modulo it with M. M is the product of several different primes.

 

Input

On the first line there is an integer T(T≤20) representing the number of test cases.

Each test case starts with three integers n,m,k(1≤m≤n≤1018,1≤k≤10) on a line where k is the number of primes. Following on the next line are k different primes p1,...,pk. It is guaranteed that M=p1⋅p2⋅⋅⋅pk≤1018 and pi≤105 for every i∈{1,...,k}.

 

Output

For each test case output the correct combination on a line.

 

Sample Input

1

9 5 2

3 5

Sample Output

6

题意：就是让你求组合数C(n,m)的值模M=p1*p2*...pk的值这写p；

思路：中国剩余定理+lucas定理；

因为组合数比较大，模数乘起来也很大，所以我们先用lucas定理求出对每个模数所求得的模，然后再通过中国剩余定理求对那个大模数的模；

在使用中国剩余定理的时候，最后那个M可能会很大，所以乘法的时候可能会爆LL，要用快速乘去处理

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#include<stdlib.h>
#include<queue>
#include<map>
#include<math.h>
using namespace std;
typedef long long LL;
int mod[20];
LL a[100005];
LL yu[30];
LL quick(LL n,LL m,LL p)
{
        LL ans=1;
        while(m)
        {
                if(m&1)
                {
                        ans=ans*n%p;
                }
                n=n*n%p;
                m/=2;
        }
        return ans;
}
LL lucas(LL n,LL m,LL p)
{
        if(n==0)
        {
                return 1;
        }
        else
        {
                LL nn=n%p;
                LL mm=m%p;
                if(mm<nn)
                        return 0;
                else
                {
                        LL ni=a[mm-nn]*a[nn]%p;
                        ni=a[mm]*quick(ni,p-2,p)%p;
                        return ni*lucas(n/p,m/p,p);
                }
        }
}
LL mul(LL n, LL m,LL p)
{
        n%=p;
        m%=p;
        LL ret=0;
        while(m)
        {
                if(m&1)
                {
                        ret=ret+n;
                        ret%=p;
                }
                m>>=1;
                n<<=1;
                n%=p;
        }
        return ret;
}
int main(void)
{
        LL n,m;
        int k;
        int t;
        scanf("%d",&k);
        int i,j;
        while(k--)
        {
                scanf("%lld %lld %d",&n,&m,&t);
                for(i=0; i<t; i++)
                {
                        scanf("%d",&mod[i]);
                        a[0]=1;
                        a[1]=1;
                        for(j=2; j<mod[i]; j++)
                        {
                                a[j]=a[j-1]*j%mod[i];
                        }
                        yu[i]=lucas(m,n,mod[i]);
                }
                LL sum=1;
                for(i=0; i<t; i++)
                {
                        sum*=(LL)mod[i];
                }
                LL acc=0;
                for(i=0; i<t; i++)
                {
                        LL kk=sum/mod[i];
                        LL ni=quick(kk%mod[i],mod[i]-2,mod[i]);
                        acc=(acc+mul(yu[i],mul(kk,ni,sum),sum)%sum)%sum;

                }
                acc=acc%sum+sum;
                acc%=sum;
                printf("%lld
",acc);
        }
        return 0;
}