A Simple Chess (Lucas组合数 + 容斥)

　　题意：走马步，要求向右向下，不能走进禁止的点。求方案数。

　　思路：若是n*m比较小的话，那么可以直接DP。但是这道题目不行。不过我们仔细分析可以知道从某个点到某个点是一个组合数，但是数据太大，mod值很小，所以只能用Lucas定理。然后DP一下到某个点不经过之前的点的方案数一直推下去就可以得到最终答案了。

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;

const int maxn = 1e3 + ;
const int maxm = 2e5 + ;
const int mod  = ;

ll fac[maxm], refac[maxm], dp[maxm];

ll mypow(ll a, ll p, ll mo){
    ll ret = ;
    while(p){
        if(p & ) ret = ret * a % mo;
        a = a * a % mo;
        p >>= ;
    }
    return ret;
}

void init(){
    refac[] = refac[] = fac[] = fac[] = 1LL;
    for(int i = ; i < mod; i ++) fac[i] = 1LL * fac[i - ] * i % mod;
    refac[mod - ] = mypow(fac[mod - ], mod - , mod);
    for(int i = mod - ; i > ; i --) refac[i] = 1LL * refac[i + ] * (i + ) % mod;
}

ll comb(int a, int b){
    if(a < b) return ;
    return fac[a] * refac[b] % mod * refac[a - b] % mod;
}

ll lucas(ll n, ll m){
    if(!m) return ;
    return comb(n % mod, m % mod) * lucas(n/mod, m/mod) % mod;
}

struct P{
    ll x, y;
    P(){}
    P(ll a, ll b):x(a), y(b){}
    bool operator < (const P & t) const{
        return x + y < t.x + t.y;
    }
    bool check(const P & t){
        if(x <= t.x || y <= t.y) return false;
        ll a = x - t.x, b = y - t.y ;
        if((a + b) %  !=  || a > * b ||  * a < b) return false;
        return true;
    }
    ll cnt(const P & t){
        ll dx = x - t.x, dy = y - t.y;
        ll step = (dx + dy) / ;
        return lucas(step, dx - step);
    }
};
P in[maxn];

int main(){
    init();
    int ncase = ;
    ll n, m;
    int k;

    while(~scanf("%lld%lld%d", &n, &m, &k)){
        memset(dp, , sizeof(dp));
        bool flag = true;
        for(int i = ; i < k; i ++) {
            scanf("%lld%lld", &in[i].x, &in[i].y);
            if(in[i].x == n && in[i].y == m) flag = false;
        }
        if(!flag) {
            printf("Case #%d: 0\n", ncase ++);
            continue;
        }
        if(n ==  && m == ) {
            printf("Case #%d: %lld\n", ncase ++, 1LL);
            continue;
        }
        sort(in, in + k);
        in[k].x = n, in[k].y = m;
        for(int i = ; i <= k; i ++){
            if(!in[i].check(P(, ))) continue;
            dp[i] = in[i].cnt(P(, ));
            for(int j = ; j < i; j ++){
                if(!dp[j] || !in[i].check(in[j])) continue;
                dp[i] = ((dp[i] - dp[j] * in[i].cnt(in[j])) % mod + mod ) % mod;
            }
        }
        printf("Case #%d: %lld\n", ncase ++, dp[k]);
    }
    return ;
}