bzoj 4767 两双手 - 动态规划 - 容斥原理

题目传送门

　　传送门I

　　传送门II

题目大意

　　一个无限大的棋盘上有一只马，设马在某个时刻的位置为$(x, y)$, 每次移动可以将马移动到$(x + A_x, y + A_y)$或者$(x + B_x, y + B_y)$。棋盘上有$n$个禁止位置不能经过，问马从$(0, 0)$走到$(E_x, E_y)$的方案数。

　　容斥是显然的。

　　每确定经过$k$个禁止位置的方案数的容斥系数是$(-1)^{k}$。

　　考虑带上容斥系数来动态规划，

　　注意到去掉重复的禁止位置后，$(0, 0), (E_x, E_y)$以及禁止位置构成了一个DAG。

　　容斥相当于求从$(0, 0)$到$(E_x, E_y)$的经过偶数个禁止位置的路径数减去经过奇数个禁止位置的路径数。

　　直接动态规划计数就好了。

Code

 /**
  * bzoj
  * Problem#4767
  * Accepted
  * Time: 333ms
  * Memory: 10716k
  */
 #include <iostream>
 #include <cassert>
 #include <cstdlib>
 #include <cstdio>
 #include <queue>
 #include <set>
 using namespace std;
 typedef bool boolean;

 const int N = , M = 1e9 + , D = 1e6 + ;

 int add(int a, int b) {
     return ((a += b) >= M) ? (a - M) : (a);
 }

 int sub(int a, int b) {
     return ((a -= b) < ) ? (a + M) : (a);
 }

 int mul(int a, int b) {
     return a * 1ll * b % M;
 }

 #define pii pair<int, int>
 #define fi first
 #define sc second

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

 int inv(int a, int n) {
     int x, y;
     exgcd(a, n, x, y);
     return (x < ) ? (x + n) : (x);
 }

 int fac[D], _fac[D];

 inline void prepare() {
     fac[] = ;
     for (int i = ; i < D; i++)
         fac[i] = mul(fac[i - ], i);
     _fac[D - ] = inv(fac[D - ], M);
     for (int i = D; --i; )
         _fac[i - ] = mul(_fac[i], i);
 }

 int comb(int n, int m) {
     if (n < m)
         return ;
     return mul(fac[n], mul(_fac[n - m], _fac[m]));
 }

 boolean Solve(int a1, int b1, int a2, int b2, int c1, int c2, pii& sol) {
     int d = c2 * a1 - a2 * c1, f = a1 * b2 - a2 * b1;
     if (d % f)
         return false;
     sol.sc = d / f;
     if (a1) {
         d = c1 - b1 * sol.sc;
         if (d % a1)
             return false;
         sol.fi = d / a1;
     } else {
         d = c2 - b2 * sol.sc;
         if (d % a2)
             return false;
         sol.fi = d / a2;
     }
     return sol.fi >=  && sol.sc >= ;
 }

 int n, Ex, Ey;
 int Ax, Ay, Bx, By;
 pii ps[N];
 int deg[N];
 set<pii> s;
 boolean g[N][N];

 //#define _DEBUG_
 #ifdef _DEBUG_
 FILE* fin = fopen("6.in", "r");
 #else
 FILE* fin = stdin;
 #endif

 boolean Solve(pii ps, pii pt, pii& sol) {
     return Solve(Ax, Bx, Ay, By, pt.fi - ps.fi, pt.sc - ps.sc, sol);
 }

 inline void init() {
     fscanf(fin, "%d%d%d", &Ex, &Ey, &n);
     fscanf(fin, "%d%d%d%d", &Ax, &Ay, &Bx, &By);
     for (int i = ; i <= n; i++) {
         fscanf(fin, "%d%d", &ps[i].fi, &ps[i].sc);
         if (s.count(ps[i]))
             i--, n--;
         s.insert(ps[i]);
     }
 }

 int f[N];
 queue<int> que;
 inline void solve() {
     int t = n + ;
     pii p, S(, ), T(Ex, Ey);
     ps[] = S, ps[t] = T;
     for (int i = ; i <= n; i++)
         if (Solve(S, ps[i], p))
             g[][i] = true, deg[i]++;
     for (int i = ; i <= n; i++)
         for (int j = ; j <= n; j++)
             if ((i ^ j) && Solve(ps[i], ps[j], p))
                 g[i][j] = true, deg[j]++, assert(!g[j][i]);
     for (int i = ; i <= n; i++)
         if (Solve(ps[i], T, p))
             g[i][t] = true, deg[t]++;
     if (Solve(S, T, p))
         g[][t] = true, deg[t]++;

     f[] = ;
     que.push();
     while (!que.empty()) {
         int e = que.front();
         que.pop();
         for (int i = ; i <= t; i++) {
             if (!g[e][i])
                 continue;
             Solve(ps[e], ps[i], p);
             if (i && i != t)
                 f[i] = sub(f[i], mul(f[e], comb(p.fi + p.sc, p.fi)));
             else
                 f[i] = add(f[i], mul(f[e], comb(p.fi + p.sc, p.fi)));
             if (!(--deg[i]))
                 que.push(i);
         }
     }
 //    for (int i = 1; i <= n; i++)
 //        assert(!deg[i]);
 //        if (deg[i])
 //            cerr << i << " " << ps[i].fi << " " << ps[i].sc << endl;
     printf("%d\n", f[t]);
 }

 int main() {
     prepare();
     init();
     solve();
     return ;
 }