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 = ;
 typedef long long ll;
 typedef pair<ll,ll> pii;

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

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

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

 ll qpow(ll a,ll b)
 {
     ll ans = ;
     while(b)
     {
         if(b & ) ans = ans * a % mod;
         a = a * a % mod;
         b >>= ;
     }
     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-);
 }

 int comb(int n,int m)
 {
     if(m< || n<m) return ;
     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 : ;
 }

 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)%) return -;
     ll need = (V[i].first+V[i].second-V[j].first-V[j].second) / ;
     // need 表示走过的步数
     ll step = Lucas(need, V[i].first-V[j].first-need, mod);
     // 第二个参数表示走过的两步的步数
     // 总的步数（need）中选择若干步是走两步的
     return step % mod;
 }

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