51_1118、51_1120 机器人走方格（组合+乘法逆元+卡特兰数+卢卡斯定理）

　　1118 机器人走方格

基准时间限制：1 秒 空间限制：131072 KB 分值: 0 难度：基础题

收藏

关注

M * N的方格，一个机器人从左上走到右下，只能向右或向下走。有多少种不同的走法？由于方法数量可能很大，只需要输出Mod 10^9 + 7的结果。

Input

第1行，2个数M,N，中间用空格隔开。（2 <= m,n <= 1000)

Output

输出走法的数量。

Input示例

2 3

Output示例

3

    #include<iostream>
    #include<cstdio>
    using namespace std;
    typedef long long LL;
    
    const LL mod = 1e9 + 7;
    
    void ex_gcd(LL a, LL b, LL &d, LL &x, LL &y){
        if(b==0){
            x =1; y=0 ; d = a;
            return ;
        }
        ex_gcd(b, a%b, d, y, x);
        y -= x*(a/b);
    } 
    
    //乘法逆元 ax = 1(mod m) 
    LL inverse(LL a, LL m){
        LL x, y, d;
        ex_gcd( a, m, d, x, y);    
        if(d!=1)    return 0;
        return (x%m + m)%m;
    }

    
    LL comb(LL m, LL n){
        LL t1 =1, t2=1;
        for(LL i = n-m+1 ; i<=n ; ++i)    t1 = t1*i%mod;
        for(LL i = 1 ; i<=m ; ++i)    t2 = t2*i%mod;
        return t1*inverse(t2, mod)%mod;
    } 
    
    int main(){
        int a, b;
        cin>> a >> b;
        cout<<comb(max(a-1, b-1), a+b-2)%mod<<endl;
    } 

　　这道题要注意的是： 当单纯的用组合累乘的话 1000！即使long long也会溢出 ， 所以只能乘一下， mod一下， 但是这样分子分母算出来后， 分子/分母 肯定就已经不是答案（因为 分子%mod / 分母%mod ！= ans%mod )， 此时， 就要用到乘法逆元。

　　ax ≡ 1(mod m) , 则 t1 * x * t2 mod m = t1 -> t1 / t2 = t1* x mod m （将除法转换成乘法， 保证 t1/t2 的结果为 ans%mod ）

1120 机器人走方格 V3

基准时间限制：1 秒 空间限制：131072 KB 分值: 80 难度：5级算法题

收藏

关注

N * N的方格，从左上到右下画一条线。一个机器人从左上走到右下，只能向右或向下走。并要求只能在这条线的上面或下面走，不能穿越这条线，有多少种不同的走法？由于方法数量可能很大，只需要输出Mod 10007的结果。

 

Input

输入一个数N(2 <= N <= 10^9)。

Output

输出走法的数量 Mod 10007。

Input示例

4

Output示例

10

这道题用到了卡特兰数（详情见下篇转的博客），然后外加求大组合数取模的卢卡斯定理（这个定理实在太好用了，妈妈再也不用担心组合数）！

首先给出这个Lucas定理：

 

 A、B是非负整数，p是质数。AB写成p进制：A=a[n]a[n-1]...a[0]，B=b[n]b[n-1]...b[0]。

则组合数C(A,B)与C(a[n],b[n])*C(a[n-1],b[n-1])*...*C(a[0],b[0])  modp同余

即：Lucas(n,m,p)=c(n%p,m%p)*Lucas(n/p,m/p,p) 

粗略的方便理解的方法：以求解n! % p为例，把n分段，每p个一段，每一段求的结果是一样的。但是需要单独处理每一段的末尾p, 2p, ...，把p提取出来
，会发现剩下的数正好又是(n / p)!，相当于划归成了一个子问题，这样递归求解即可。

/*
    机器人走方格V3
    时间：2016年4月20日00:05:22
    作者：W2W
*/ 

    #include<iostream>
    #include<cstdio>
    #include<iomanip>
    #include<string>
    #include<cstring>
    using namespace std;
    typedef long long LL;
    
    const LL mod = 10007;
    const LL maxn = 50001;
    
    LL fac[maxn];
    void init(LL p){
        memset(fac, 0, sizeof(fac));
        fac[1] = 1;
        for(int i=2; i<p ; ++i){
            fac[i] = fac[i-1]*i%p;
        }
    }
    
    LL qsm(LL a, LL n, LL p){
        LL res = 1;
        while(n){
            if(n&1)    res = (res*a)%p;
            a = (a*a)%p;
            n >>= 1;
        }
        return res;
    }
    
    void ex_gcd(LL a, LL b, LL& d, LL& x, LL& y){
        if(b==0){
            x = 1; y = 0 ; d = a;
            return ;
        }
        ex_gcd(b, a%b, d, y, x);
        y -= x*(a/b);
    } 
    
    LL reverse(LL a, LL m){
        LL x, y, d;
        ex_gcd(a, m, d, x, y);
        if(d==1)    return (x%m + m)%m;
        else return 0;
    }
    //卢卡斯定理  C(m, n)%p  
    LL Lucas(LL m, LL n, LL p){
        LL res = 1;
        while(n && m){
            LL n1 = n%p, m1 = m%p;
            //费马小定理求逆元 
            res = res* fac[n1]* qsm(fac[m1]*fac[n1-m1]%p, p-2, p)%p;
            //扩展欧几里得求逆元 
            //res = res* fac[n1]* reverse(fac[m1],p)* reverse(fac[n1-m1],p)%p;
            n /= p;
            m /= p;
        }
        return (res%p + p)%p;
    }
    
    int main(){
        LL n;
        init(mod);
        cin>>n;
        n--;
        //卡特兰数  C(n, 2*n)/(n+1) 
        cout<<2*Lucas(n, 2*n, mod)*reverse(n+1, mod)%mod<<endl;
        return 0;
    }