UVALive 4978 Fields and Farmers

UVALive_4978

    这个题目难点在于如何转化成数学模型，详细的转化思路还是看官方的题解吧：http://cepc10.ii.uni.wroc.pl/solutions.html。

    完成数学模型的转化之后，问题就变成了给定了若干个8bit的二进制数，求选出若干个数且这些数或起来为11111111的方法数，这一点可以用容斥原理求解。

    首先我们约定a[i]表示最终结果有且仅有i个bit为0的方案数，那么最后我们要求的就是a[0]，再约定f[i]表示让结果的8个bit中任意i个bit为0而其他位不管的总方法数，这样f[0]就是2^N。在计算f[i]的时候，先枚举是哪i位为0，然后找到这i位为0的数一共有x个，那么使得最后或起来的结果这i位为0的方案数就是2^x-1，将枚举哪i位为0时求得的这若干个2^x-1累加起来就是f[i]的值，接着我们来观察f[i]这个表达式的特征。

    显然f[0]包含了所有情况，所以有f[0]=a[0]+a[1]+a[2]+...+a[8]，然后考虑f[1]，首先对于最后结果只有1个bit为0的方案数，我们按上述计算f[i]的方法算完之后每种方案是只算了1次的，因此f[1]中有一项为a[1]，接着对于最后结果只有2个bit为0的方案数，我们在第一个为0的bit时算了一次，在第二个为0的bit时又算了一次，那么f[1]中就会有一项为C(2,1)*a[2]，也就是2*a[2]。这样依次类推，就会得到f[1]的表达式f[1]=C(1,1)*a[1]+C(2,1)*a[2]+...+C(8,1)*a[8]。

    同理我们可以得到f[2]=C(2,2)*a[2]+C(3,2)*a[3]+...+C(8,2)*a[8]，也就可以推得剩下的f[i]了。

    这时我们根据写出的有限项就不难发现a[0]=f[0]-f[1]+f[2]-f[3]+...-f[7]+f[8]。于是按上述方法计算出f[i]就可以得到a[0]了。

#include<stdio.h>
#include<string.h>
#include<algorithm>
#define MAXD 1000010
#define INF 0x3f3f3f3f
#define MOD 1000000007
typedef long long LL;
int dx[] = {1, 1, 0, 0, 1, 1, 1, 1}, dy[] = {0, 0, 1, 1, 1, 1, -1, -1}, d[8];
int N, h[260], x[MAXD], y[MAXD];
char ch;
void init()
{
    int i, j;
    scanf("%d", &N);
    d[0] = d[2] = d[4] = d[6] = INF, d[1] = d[3] = d[5] = d[7] = -INF;
    for(i = 0; i < N; i ++)
    {
        scanf("%d%d", &x[i], &y[i]);
        d[0] = std::min(d[0], x[i]), d[1] = std::max(d[1], x[i]);
        d[2] = std::min(d[2], y[i]), d[3] = std::max(d[3], y[i]);
        d[4] = std::min(d[4], x[i] + y[i]), d[5] = std::max(d[5], x[i] + y[i]);
        d[6] = std::min(d[6], x[i] - y[i]), d[7] = std::max(d[7], x[i] - y[i]);
    }
    memset(h, 0, sizeof(h));
    for(i = 0; i < N; i ++)
    {
        int t = 0;
        for(j = 0; j < 8; j ++)
        {
            if(dx[j] * x[i] + dy[j] * y[i] == d[j]) t = t << 1 | 1;
            else t <<= 1;
        }
        ++ h[t];
    }
}
LL powmod(LL a, int n)
{
    LL ans = 1;
    while(n)
    {
        if(n & 1) ans = ans * a % MOD;
        n >>= 1, a = a * a % MOD;
    }
    return ans;
}
void dfs(int cur, int st, int n, int &ans)
{
    if(cur == 8)
    {
        int i, num = 0;
        for(i = 0; i < 256; i ++)
            if((~st & i) == 0) num += h[i];
        if(n & 1) ans = (ans - powmod(2, num)) % MOD;
        else ans = (ans + powmod(2, num)) % MOD;
        return ;
    }
    dfs(cur + 1, st, n + 1, ans);
    dfs(cur + 1, st | 1 << cur, n, ans);
}
void solve()
{
    int ans = 0;
    dfs(0, 0, 0, ans);
    if(ans < 0) ans += MOD;
    printf("%d\n", ans);
}
int main()
{
    int t;
    scanf("%d", &t);
    while(t --)
    {
        init();
        solve();
    }
    return 0;
}