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 = 505, M = 1e9 + 7, D = 1e6 + 1;

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

int sub(int a, int b) {
    return ((a -= b) < 0) ? (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 = 1, y = 0;
    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 < 0) ? (x + n) : (x);
}

int fac[D], _fac[D];

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

int comb(int n, int m) {
    if (n < m)
        return 0;
    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 >= 0 && sol.sc >= 0; 
}

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 = 1; 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 + 1;
    pii p, S(0, 0), T(Ex, Ey);
    ps[0] = S, ps[t] = T;
    for (int i = 1; i <= n; i++)
        if (Solve(S, ps[i], p))
            g[0][i] = true, deg[i]++;
    for (int i = 1; i <= n; i++)
        for (int j = 1; 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 = 1; i <= n; i++)
        if (Solve(ps[i], T, p))
            g[i][t] = true, deg[t]++;
    if (Solve(S, T, p))
        g[0][t] = true, deg[t]++;

    f[0] = 1;
    que.push(0);
    while (!que.empty()) {
        int e = que.front();
        que.pop();
        for (int i = 1; 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 0;
}