[BZOJ5248][九省联考2018]一双木棋(连通性DP,对抗搜索)

5248: [2018多省省队联测]一双木棋

Time Limit: 20 Sec  Memory Limit: 512 MB
Submit: 43  Solved: 34
[Submit][Status][Discuss]

Description

菲菲和牛牛在一块n行m列的棋盘上下棋，菲菲执黑棋先手，牛牛执白棋后手。棋局开始时，棋盘上没有任何棋子，

两人轮流在格子上落子，直到填满棋盘时结束。落子的规则是：一个格子可以落子当且仅当这个格子内没有棋子且

这个格子的左侧及上方的所有格子内都有棋子。

棋盘的每个格子上，都写有两个非负整数，从上到下第i行中从左到右第j列的格子上的两个整数记作Aij、Bij。在

游戏结束后，菲菲和牛牛会分别计算自己的得分：菲菲的得分是所有有黑棋的格子上的Aij之和，牛牛的得分是所

有有白棋的格子上的Bij的和。

菲菲和牛牛都希望，自己的得分减去对方的得分得到的结果最大。现在他们想知道，在给定的棋盘上，如果双方都

采用最优策略且知道对方会采用最优策略，那么，最终的结果如何

Input

第一行包含两个正整数n,m，保证n,m≤10。

接下来n行，每行m个非负整数，按从上到下从左到右的顺序描述每个格子上的

第一个非负整数：其中第i行中第j个数表示Aij。

接下来n行，每行m个非负整数，按从上到下从左到右的顺序描述每个格子上的

第二个非负整数：其中第i行中第j个数表示Bij

n, m ≤ 10 ， Aij, Bij ≤ 100000

Output

输出一个整数，表示菲菲的得分减去牛牛的得分的结果。

Sample Input

2 3
2 7 3
9 1 2
3 7 2
2 3 1

Sample Output

2

HINT

Source

[Submit][Status][Discuss]

这套卷子真的是CCF卷的风格。。专门克制我这种做题慢如蜗牛的人。。

首先这个题一看范围就差不多了，不是搜索就是DP，要拿满分显然得记忆化。因为博弈的最佳决策是根据后继状态选择的，所以返回的是某个状态之后可能拉出的最大/最小分差。由于先手是想让A-B最大，后手反之，交替进行，所以我们搜索时分两种情况讨论一下，最终一定能得到最优决策下的答案。

至于怎么存储当前状态，直接状压每行放了多少个棋子即可，状态直接转移。我起先是按照11进制存储状态的，发现跑了0.99s，后来改成16进制用位运算代替除法取模，就只要0.29s了。

还有一种方法是连通性DP，将从左下到右上的轮廓线压进二进制里转移（0表示向上，1表示向右）。

方法一：

 #include<cstdio>
 #include<algorithm>
 #define rep(i,l,r) for (int i=l; i<=r; i++)
 typedef long long ll;
 using namespace std;

 const int N=,inf=,P=;
 ll H[P],G; int H1[P];
 int n,m,a[N][N],b[N][N],p[N];

 void inc(int &x){ x++; if (x>=P) x-=P; }
 void Hash(ll S,int k){ int x=S%P; while (H[x]) inc(x); H[x]=S; H1[x]=k; }
 int Find(ll S){ int x=S%P; while (H[x]!=S && H[x]) inc(x); return H1[x]; }

 int get(ll S,int x){ if (!x) return m; x=n-x; while (x--) S>>=; return S&; }
 ll upd(ll S,int x){
     if (x==){
         int tot=;
         rep(i,,n-) p[tot++]=S&,S>>=; S++;
         while (tot--) S=(S<<)+p[tot];
         return S;
     }
     int tot=;
     rep(i,,n-x) p[tot++]=S&,S>>=; S++;
     while (tot--) S=(S<<)+p[tot];
     return S;
 }

 int dfs(ll S,int x){
     int t=Find(S); if (t) return t;
     if (S==G-) return (x ? -b[n][m] : a[n][m]);
     if (x==){
         int res=-inf;
         rep(i,,n) if (get(S,i)<get(S,i-)) res=max(res,a[i][get(S,i)+]+dfs(upd(S,i),x^));
         Hash(S,res); return res;
     }else{
         int res=inf;
         rep(i,,n) if (get(S,i)<get(S,i-)) res=min(res,dfs(upd(S,i),x^)-b[i][get(S,i)+]);
         Hash(S,res); return res;
     }
 }

 int main(){
     freopen("chess.in","r",stdin);
     freopen("chess.out","w",stdout);
     scanf("%d%d",&n,&m);
     rep(i,,n) G=G*+m;
     rep(i,,n) rep(j,,m) scanf("%d",&a[i][j]);
     rep(i,,n) rep(j,,m) scanf("%d",&b[i][j]);
     printf("%d\n",dfs(,));
     return ;
 }

方法二：

 #include<cstdio>
 #include<algorithm>
 #define rep(i,l,r) for (int i=l; i<=r; i++)
 using namespace std;

 const int N=,inf=;
 int n,m,a[N][N],b[N][N],f[<<],p[]={};

 int cnt(int x){ int res=; for (; x; x>>=) if (x&) res++; return res; }
 int work(int x){
     int res=,w=;
     for (; x; x>>=) if (x&) res+=w; else w++;
     return res;
 }
 int valA(int v,int s){ int g=cnt(v&(p[s]-)); return a[n-s+g][+g]; }
 int valB(int v,int s){ int g=cnt(v&(p[s]-)); return b[n-s+g][+g]; }

 void solve(int S,int x){
     int res;
     if (x){
         res=inf;
         for (int i=; i<n+m-; i++)
             if (!(p[i]&S) && (p[i+]&S))
                 res=min(res,f[S^p[i]^p[i+]]-valB(S,i));
     }else{
         res=-inf;
         for (int i=; i<n+m-; i++)
             if (!(p[i]&S) && (p[i+]&S))
                 res=max(res,f[S^p[i]^p[i+]]+valA(S,i));
     }
     f[S]=res;
 }

 int main(){
     freopen("chess.in","r",stdin);
     freopen("chess.out","w",stdout);
     scanf("%d%d",&n,&m);
     rep(i,,n) rep(j,,m) scanf("%d",&a[i][j]);
     rep(i,,n) rep(j,,m) scanf("%d",&b[i][j]);
     p[]=; rep(i,,n+m) p[i]=p[i-]<<;
     f[p[m]-]=;
     rep(i,p[m],p[n+m]-p[n])
         if (cnt(i)==m) solve(i,(n*m-work(i))&);
     printf("%d\n",f[p[n+m]-p[n]]);
     return ;
 }