BZOJ 3901 棋盘游戏 解题报告

这题有个重要性质：

我们设 Flag[i][j] 表示 (i, j) 是否被奇数个操作所覆盖，

也就是操作次数对 2 取模。

设 x = (n + 1) / 2。

那么对于所有的合法的操作方案，

令 1 <= i <= x , 1 <= j < x，

都有 Flag[i][j] ^ Flag[i][x] ^ Flag[i][j + x] = 0

令 1 <= i < x , 1 <= j <= x，

都有 Flag[i][j] ^ Flag[x][j] ^ Flag[i + x][j] = 0

考虑任意一次操作，如果覆盖了 (i, x)，

那么在 (i, j) 和 (i, j + x) 中必然有且仅有一个被覆盖。

(i, j) 和 (i + x, j) 同理，

于是每次都会改变那个三元组中的两个元素，或者一个都不改变。

所以这个性质也是成立的。

那么怎么说明满足上述性质的 Flag[][] 就可以对应一个合法的方案呢？

我们考虑：

我们无论怎样在这个满足性质的 Flag[][] 基础上进行操作，

这个 Flag[][] 还会是满足性质的。

先不考虑其他格子的 Flag[][] 值，

我们考虑所有的 1 <= i <= x，1 <= j <= x：

我们都可以把 Flag[i][j] 变成 0。

然后我们考虑对于所有的 1 <= i <= x，x < j <= n：

Flag[i][j] = Flag[i][x] ^ Flag[i][j - x] = 0 ^ 0 = 0

同理，其他格子的 Flag[][] 值也都会是 0。

于是满足上述性质的 Flag[][] 就可以对应一个合法的方案。

好了，那么我们就暴力枚举 Flag[x][1] - Flag[x][x] 的值，

然后 Flag[x][x + 1] - Flag[x][n] 的值也就可以确定了，

其次再分别枚举 Flag[1][x] - Flag[x - 1][x] 的值，

（这里是指一个一个处理这些值，不用再 dfs 了）

那么 Flag[x + 1][x] - Flag[n][x] 的值也可以确定了。

在此基础上对于 1 < i < x，1 < j < x：

我们可以枚举 Flag[i][j] 的值，

那么 Flag[i + x][j], Flag[i][j + x], Flag[i + x][j + x] 的值都可以确定，

于是取最优值即可。

复杂度 O(1.4^n * n^2)。

毕竟 Gromah 太弱，只会做水题。

 #include <cmath>
 #include <cstdio>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 #define N 33 + 5
 #define INF 0x7fffffff

 int n, x, Max, A[N][N];
 bool Flag[N][N];

 inline int get(int u)
 {
     return u ==  ? - : ;
 }

 inline int Calc()
 {
     for (int i = x + ; i <= n; i ++)
         Flag[i][x] = Flag[x][x] ^ Flag[i - x][x];
     int res = ;
     for (int i = ; i <= n; i ++)
         res += get(Flag[i][x]) * A[i][x];
     for (int i = ; i < x; i ++)
     {
         int _Max = -INF, sum;
         for (int k = ; k < ; k ++)
         {
             Flag[x][i] = k;
             Flag[x][i + x] = Flag[x][i] ^ Flag[x][x];
             sum = get(Flag[x][i]) * A[x][i] + get(Flag[x][i + x]) * A[x][i + x];
             for (int j = ; j < x; j ++)
             {
                 int _res = -INF;
                 for (int _k = ; _k < ; _k ++)
                 {
                     Flag[j][i] = _k;
                     Flag[j][i + x] = Flag[j][i] ^ Flag[j][x];
                     Flag[j + x][i] = Flag[j][i] ^ Flag[x][i];
                     Flag[j + x][i + x] = Flag[j + x][i] ^ Flag[j + x][x];
                     int _sum = get(Flag[j][i]) * A[j][i] + get(Flag[j][i + x]) * A[j][i + x];
                     _sum += get(Flag[j + x][i]) * A[j + x][i] + get(Flag[j + x][i + x]) * A[j + x][i + x];
                     _res = max(_res, _sum);
                 }
                 sum += _res;
             }
             _Max = max(_Max, sum);
         }
         res += _Max;
     }
     return res;
 }

 inline void dfs(int z)
 {
     if (z > x)
     {
         Max = max(Max, Calc());
         return ;
     }
     Flag[z][x] = ;
     dfs(z + );
     Flag[z][x] = ;
     dfs(z + );
 }

 int main()
 {
     #ifndef ONLINE_JUDGE
         freopen("3901.in", "r", stdin);
         freopen("3901.out", "w", stdout);
     #endif

     scanf("%d", &n);
     x = n +  >> ;
     for (int i = ; i <= n; i ++)
         for (int j = ; j <= n; j ++)
             scanf("%d", A[i] + j);
     dfs();
     printf("%d\n", Max);

     #ifndef ONLINE_JUDGE
         fclose(stdin);
         fclose(stdout);
     #endif
     return ;
 }