HDU 5794 A Simple Chess ——（Lucas + 容斥）

　　网上找了很多人的博客，都看不太懂，还是大力学长的方法好。

　　要说明的一点是，因为是比较大的数字的组合数再加上mod比较小，因此用Lucas定理求组合数。

　　代码如下（有注释）：

#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <set>
#include <vector>
using namespace std;
const int mod = 110119;
typedef long long ll;
typedef pair<ll,ll> pii;

int k;
ll fact[120000+5],dp[100+5];
ll n,m;
vector<pii> V;

void init()
{
    fact[0] = fact[1] = 1;
    for(int i=2;i<=120000;i++) fact[i] = fact[i-1] * i % mod;
}

void ex_gcd(ll a,ll b,ll &x,ll &y,ll &d)
{
    if(!b) {d = a; x = 1; y = 0;}
    else
    {
        ex_gcd(b,a%b,y,x,d);
        y -= x * (a/b);
    }
}

ll qpow(ll a,ll b)
{
    ll ans = 1;
    while(b)
    {
        if(b & 1) ans = ans * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return ans;
}

ll inv(ll t,ll p)
{
    /*ll x,y,d;
    ex_gcd(t,p,x,y,d);
    return d==1 ? (x%mod+mod)%mod : -1;*/
    return qpow(t,p-2);
}

int comb(int n,int m)
{
    if(m<0 || n<m) return 0;
    return fact[n] * 1LL * inv(fact[m],mod) % mod * inv(fact[n-m],mod) % mod;
}

ll Lucas(ll n,ll m,int p)
{
    return m ? Lucas(n/p,m/p,p) * comb(n%p,m%p) % mod : 1;
}

ll solve(int i,int j) // j to i 的无视障碍的步数总数
{
    if(V[i].second < V[j].second || V[i].first < V[i].first || (V[i].first+V[i].second-V[j].first-V[j].second)%3) return -1;
    ll need = (V[i].first+V[i].second-V[j].first-V[j].second) / 3;
    // need 表示走过的步数
    ll step = Lucas(need, V[i].first-V[j].first-need, mod);
    // 第二个参数表示走过的两步的步数
    // 总的步数（need）中选择若干步是走两步的
    return step % mod;
}

int main()
{
    init();
    int kase = 1;
    while(scanf("%I64d%I64d%d",&n,&m,&k)==3)
    {
        V.clear();
        for(int i=1;i<=k;i++)
        {
            ll x,y;scanf("%I64d%I64d",&x,&y);
            V.push_back(pii(x,y));
        }
        V.push_back(pii(1,1));
        V.push_back(pii(n,m));
        sort(V.begin(),V.end());
        memset(dp,0,sizeof(dp));
        int sz = V.size();
        for(int i=1;i<sz;i++)
        {
            dp[i] = solve(i,0);
            if(dp[i] == -1) dp[i] = 0;
            for(int j=0;j<i;j++)
            {
                ll step = solve(i,j);
                if(step != -1)
                {
                    dp[i] -= step * dp[j] % mod;
                    // 所有从原点到i这个点的路径中，从原点到禁止点再从该禁止点到i点的所有路径都是不被允许的，需要减掉
                    if(dp[i] < 0) dp[i] = ((dp[i] % mod) + mod) % mod;
                }
            }
        }
        printf("Case #%d: %I64d
",kase++,dp[sz-1]);
    }
}