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

最新推荐文章于 2024-08-26 16:54:27 发布
最新推荐文章于 2024-08-26 16:54:27 发布
阅读量75 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/lrj998244353/p/8763289.html
版权

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

题解1

直接对抗搜索可以得50分

题解2

对抗搜索+Alpha-Beta剪枝可以得70分

题解3

对抗搜索+记忆化可以得100分

就是开一个map存一下每个状态的值，如果访问过这个状态直接返回即可。

由于任意时刻棋盘上的棋子一定是四连通且聚集在左上角，中间不会有空洞，因此就可以把状态按照每行的个数压成一个M进制数。枚举下棋的位置时也不用所有的位置都枚举，只用枚举下到哪一行即可。

代码1 (50pts)

#include<bits/stdc++.h>
#define MAXN 22
#define INF 0x7fffffff
#define LL long long
namespace IO{
    char buf[1<<15],*fs,*ft;
    inline char gc(){return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;}
    inline int qr(){
        int x=0,rev=0,ch=gc();
        while(ch<'0'||ch>'9'){if(ch=='-')rev=1;ch=gc();}
        while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+ch-'0';ch=gc();}
        return rev?-x:x;}
}using namespace IO;
using namespace std;
int num[MAXN],N,M,a[MAXN][MAXN],b[MAXN][MAXN];
int Alpha_Beta(int now,int alpha,int beta){
    if(now==N*M)return 0;
    if(!(now&1)){//先手 
        alpha=-INF;
        if(num[1]<M){
            num[1]++;
            alpha=max(alpha,Alpha_Beta(now+1,alpha,beta)+a[1][num[1]]);
            num[1]--;
        }
        for(int i=2;i<=N;i++){
            if(num[i]>=num[i-1])continue;
            num[i]++;
            alpha=max(alpha,Alpha_Beta(now+1,alpha,beta)+a[i][num[i]]);
            num[i]--;
        }
        return alpha;
    }
    else{//后手 
        beta=INF;
        if(num[1]<M){
            num[1]++;
            beta=min(beta,Alpha_Beta(now+1,alpha,beta)-b[1][num[1]]);
            num[1]--;
        }
        for(int i=2;i<=N;i++){
            if(num[i]>=num[i-1])continue;
            num[i]++;
            beta=min(beta,Alpha_Beta(now+1,alpha,beta)-b[i][num[i]]);
            num[i]--;
        }
        return beta;
    }
}
int main(){
    #ifndef ONLINE_JUDGE
    freopen("chess.in","r",stdin);
    freopen("chess.out","w",stdout);
    #endif
    N=qr();M=qr();
    for(int i=1;i<=N;i++){
        for(int j=1;j<=M;j++){
            a[i][j]=qr(); 
        }
    }
    for(int i=1;i<=N;i++){
        for(int j=1;j<=M;j++){
            b[i][j]=qr(); 
        }
    }
    printf("%d",Alpha_Beta(0,-INF,INF));
    return 0;
}

代码2 (70pts)

#include<bits/stdc++.h>
#define MAXN 22
#define INF 0x7fffffff
#define LL long long
namespace IO{
    char buf[1<<15],*fs,*ft;
    inline char gc(){return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;}
    inline int qr(){
        int x=0,rev=0,ch=gc();
        while(ch<'0'||ch>'9'){if(ch=='-')rev=1;ch=gc();}
        while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+ch-'0';ch=gc();}
        return rev?-x:x;}
}using namespace IO;
using namespace std;
int num[MAXN],N,M,a[MAXN][MAXN],b[MAXN][MAXN];
int Alpha_Beta(int now,int alpha,int beta,int nowa,int nowb){
    if(now==N*M)return nowa-nowb;
    if(!(now&1)){//先手 
        if(num[1]<M){
            num[1]++;
            alpha=max(alpha,Alpha_Beta(now+1,alpha,beta,nowa+a[1][num[1]],nowb));
            num[1]--;
            if(alpha>=beta)return alpha;
        }
        for(int i=2;i<=N;i++){
            if(num[i]>=num[i-1])continue;
            num[i]++;
            alpha=max(alpha,Alpha_Beta(now+1,alpha,beta,nowa+a[i][num[i]],nowb));
            num[i]--;
            if(alpha>=beta)return alpha;
        }
        return alpha;
    }
    else{//后手 
        if(num[1]<M){
            num[1]++;
            beta=min(beta,Alpha_Beta(now+1,alpha,beta,nowa,nowb+b[1][num[1]]));
            num[1]--;
            if(alpha>=beta)return beta;
        }
        for(int i=2;i<=N;i++){
            if(num[i]>=num[i-1])continue;
            num[i]++;
            beta=min(beta,Alpha_Beta(now+1,alpha,beta,nowa,nowb+b[i][num[i]]));
            num[i]--;
            if(alpha>=beta)return beta;
        }
        return beta;
    }
}
int main(){
    #ifndef ONLINE_JUDGE
    freopen("chess.in","r",stdin);
    freopen("chess.out","w",stdout);
    #endif
    N=qr();M=qr();
    for(int i=1;i<=N;i++){
        for(int j=1;j<=M;j++){
            a[i][j]=qr(); 
        }
    }
    for(int i=1;i<=N;i++){
        for(int j=1;j<=M;j++){
            b[i][j]=qr(); 
        }
    }
    printf("%d",Alpha_Beta(0,-INF,INF,0,0));
    return 0;
}

代码3 (AC)

#include<bits/stdc++.h>
#define MAXN 22
#define INF 0x7fffffff
#define LL long long
namespace IO{
    char buf[1<<15],*fs,*ft;
    inline char gc(){return (fs==ft&&(ft=(fs=buf)+fread(buf,1,1<<15,stdin),fs==ft))?0:*fs++;}
    inline int qr(){
        int x=0,rev=0,ch=gc();
        while(ch<'0'||ch>'9'){if(ch=='-')rev=1;ch=gc();}
        while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+ch-'0';ch=gc();}
        return rev?-x:x;}
}using namespace IO;
using namespace std;
map<LL,int> mp;
int num[MAXN],N,M,a[MAXN][MAXN],b[MAXN][MAXN];
inline LL Hash(){
    LL ret=0;
    for(int i=1;i<=N;i++)ret=ret*(M+1)+num[i];
    return ret;
}
int DFS(int now){
    LL tmp=Hash();
    if(mp.find(tmp)!=mp.end())return mp[tmp];
    if(now==N*M)return 0;
    int val;
    if(!(now&1)){//先手 
        val=-INF;
        if(num[1]<M){
            num[1]++;
            val=max(val,DFS(now+1)+a[1][num[1]]);
            num[1]--;
        }
        for(int i=2;i<=N;i++){
            if(num[i]>=num[i-1])continue;
            num[i]++;
            val=max(val,DFS(now+1)+a[i][num[i]]);
            num[i]--;
        }
        mp[tmp]=val;
    }
    else{//后手 
        val=INF;
        if(num[1]<M){
            num[1]++;
            val=min(val,DFS(now+1)-b[1][num[1]]);
            num[1]--;
        }
        for(int i=2;i<=N;i++){
            if(num[i]>=num[i-1])continue;
            num[i]++;
            val=min(val,DFS(now+1)-b[i][num[i]]);
            num[i]--;
        }
        mp[tmp]=val;
    }
    return mp[tmp];
}
int main(){
    #ifndef ONLINE_JUDGE
    freopen("chess.in","r",stdin);
    freopen("chess.out","w",stdout);
    #endif
    N=qr();M=qr();
    for(int i=1;i<=N;i++){
        for(int j=1;j<=M;j++){
            a[i][j]=qr(); 
        }
    }
    for(int i=1;i<=N;i++){
        for(int j=1;j<=M;j++){
            b[i][j]=qr(); 
        }
    }
    printf("%d",DFS(0));
    return 0;
}

转载于:https://www.cnblogs.com/lrj998244353/p/8763289.html

weixin_30295091
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算表格（计蒜客）的c语言解法
vbayyds的博客
12-13 828
蒜头君得到了一个n行m列的表格，他认为第i行j列的数的重要度为∣i−j∣。 他想把表格中每个数乘上这个格子的重要度再全部加起来得到一个总和，你能帮他算出这个总和吗？ 输入格式 第一行，两个正整数n,m 接下来n行，每行m个正整数aij​ 输出格式 输出一行，包含一个整数，表示答案。 数据范围 对于60%的数据，1≤n,m≤100,1≤aij​≤100。 对于100\%100%的数据，1<= n,m <=1000, 1≤aij​≤1000000000 ...
JZOJ 5637. 【NOI2018模拟4.8】一双木棋
Felix-Lee的博客
04-08 211
JZOJ 5637. 【NOI2018模拟4.8】一双木棋 Description菲菲和牛牛在一块n 行m 列的棋盘上下棋，菲菲执黑棋先手，牛牛执白棋后手。 棋局开始时，棋盘上没有任何棋子，两人轮流在格子上落子，直到填满棋盘时结 束。落子的规则是：一个格子可以落子当且仅当这个格子内没有棋子且这个格子的左侧 及上方的所有格子内都有棋子。 棋盘的每个格子上，都写有两个非负整数，从上
洛谷P4363 [九省联考2018]一双木棋chess
qq_41510496的博客
06-01 487
题目描述菲菲和牛牛在一块n 行m 列的棋盘上下棋，菲菲执黑棋先手，牛牛执白棋后手。 棋局开始时，棋盘上没有任何棋子，两人轮流在格子上落子，直到填满棋盘时结束。落子的规则是：一个格子可以落子当且仅当这个格子内没有棋子且这个格子的左侧及上方的所有格子内都有棋子。棋盘的每个格子上，都写有两个非负整数，从上到下第i 行中从左到右第j 列的格 子上的两个整数记作 A_{i,j}Ai,j​ 、 B_{i,j}...
浙大版《Python 程序设计》题目集第4章-17——第4章-21
hmh4640219的博客
02-03 1314
第4章-17 水仙花数（20 分）第4章-18 猴子选大王第4章-19 矩阵运算第4章-20 求矩阵各行元素之和第4章-21 判断上三角矩阵 第4章-17 水仙花数（20 分） 水仙花数是指一个N位正整数（N≥3），它的每个位上的数字的N次幂之和等于它本身。 例如：153=1×1×1+5×5×5+3×3×3。 本题要求编写程序,计算所有N位水仙花数。 输入格式: 输入在一行中给出一个正整数N（3≤N≤5） 输出格式: 按递增顺序输出所有N位水仙花数，每个数字占一行。 输入样例: 在这里给出一组输入。例如：.
2022.03.27网易算法第四题
Annie_0321的博客
03-27 1185
题目描述： 小红来到了一片沼泽地的岸边，她希望通过这片沼泽地。 这个沼泽地地图用一个矩阵进行表示。1代表沼泽，0代表平地，小红刚开始在矩阵的左上角，她需要从右下角离开地图。已知进入地图和离开地图的时间可以忽略。小红可以向左、向右或者向下走。 当小红从沼泽进入沼泽，或者从平地进入平地时，需要花费1单位时间。 当小红从沼泽进入平地，或者从平地进入沼泽时，由于需要换装备，所以要花2单位时间。 小红可以从左上角进入地图，从右下角离开地图。 小红想知道，经过这片沼泽地，最少需要花费多少单位时间。 输入描述： 第一行输
bzoj5248 [2018多省省队联测]一双木棋
C_K_Y_的博客
04-09 594
5248: [2018多省省队联测]一双木棋Time Limit: 20 Sec  Memory Limit: 512 MBSubmit: 155  Solved: 132[Submit][Status][Discuss]Description菲菲和牛牛在一块n行m列的棋盘上下棋，菲菲执黑棋先手，牛牛执白棋后手。棋局开始时，棋盘上没有任何棋子，两人轮流在格子上落子，直到填满棋盘时结束。落子的规则是...
BZOJ5248 [2018多省省队联测]一双木棋（状压+记忆化搜索）
XHRlyb的博客
04-09 441
题目链接：BZOJ 5248题目描述： 菲菲和牛牛在一块n行m列的棋盘上下棋(n,m<=10)，菲菲执黑棋先手，牛牛执白棋后手。棋局开始时，棋盘上没有任何棋子，两人轮流在格子上落子，直到填满棋盘时结束。落子的规则是：一个格子可以落子当且仅当这个格子内没有棋子且这个格子的左侧及上方的所有格子内都有棋子。 棋盘的每个格子上，都写有两个非负整数，从上到下第i行中从左到右第j列的格子上的两个整数记作Ai
【BZOJ5248】【2018多省省队联测】一双木棋
cz_xuyixuan的博客
04-09 330
【题目链接】点击打开链接【思路要点】显然，任意时刻游戏棋盘的轮廓线是单调的。因此，我们可以用一个\(O(N+M)\)位的二进制数描述一个轮廓线。记忆化搜索即可，时间复杂度\(O(M*\binom{N+M}{N})\)。【代码】#include&lt;bits/stdc++.h&gt; using namespace std; const int MAXN = 105; const int MAXS...
bzoj 5248: [2018多省省队联测]一双木棋 博弈论+状压dp
beginend
04-07 368
题意 菲菲和牛牛在一块n行m列的棋盘上下棋，菲菲执黑棋先手，牛牛执白棋后手。棋局开始时，棋盘上没有任何棋子，两人轮流在格子上落子，直到填满棋盘时结束。落子的规则是：一个格子可以落子当且仅当这个格子内没有棋子且这个格子的左侧及上方的所有格子内都有棋子。棋盘的每个格子上，都写有两个非负整数，从上到下第i行中从左到右第j列的格子上的两个整数记作Aij、Bij。在游戏结束后，菲菲和牛牛会分别计算自己的得...
bzoj 5252 [2018多省省队联测]林克卡特树
Elijahqi
07-20 372
Description 小L最近沉迷于塞尔达传说：荒野之息（The Legend of Zelda: Breath of The Wild）无法自拔 他尤其喜欢游戏中的迷你挑战。 游戏中有一个叫做“LCT”的挑战，它的规则是这样子的：现在有一个N个点的树（Tree），每条边有一个整数边权 vi，若vi&gt;=0，表示走这条边会获得vi的收益；若vi&lt;0，则表示走这条边需要支付-vi...
BZOJ5218: [Lydsy2017省队十连测]友好城市（kosaraju算法）
DZYO的博客
09-25 419
传送门 题解： 利用kosaraju+bitset可以在知道邻接矩阵的情况下O(n232)O(\frac{n^2}{32})O(32n2​)解决强连通分量计数。 用回滚莫队即可在O(mm)O(m \sqrt{m})O(mm​)的时间内获得所有询问的邻接矩阵了。 时间复杂度O(mm+qn232)O( m\sqrt{m} + q\frac{n^2}{32})O(mm​+q32n2​)。 #includ...
BZOJ5220: [Lydsy2017省队十连测]异或与区间加
DZYO的博客
09-22 543
传送门 题解： 首先前缀异或处理一下，变成一堆数中两个异或为kkk。 显然这是一一对应的关系，如果一对数中两个都小于n\sqrt{n}n​个，直接暴力O(nn)O(n\sqrt{n})O(nn​)解决。 否则在序列上O(n)O(n)O(n)解决一对数。 时间复杂度O(nn)O(n\sqrt{n})O(nn​)。 #include &lt;bits/stdc++.h&gt; using namesp...
BZOJ5223: [Lydsy2017省队十连测]有理有据题（KD树）
DZYO的博客
09-28 351
传送门 题解： KD树支持矩阵加1，矩阵赋0，查询历史最大值。 时间复杂度O((m+A)n+Clog⁡n+qn)O((m+A)\sqrt{n} + C \log n + qn)O((m+A)n​+Clogn+qn)。 代码标记用了二元组，没把常数压下去。。 #include &lt;bits/stdc++.h&gt; using namespace std; const int RLEN=1&l...
【BZOJ】5232: [Lydsy2017省队十连测]好题-最短路
远行客
10-29 436
最短路
给自己复盘的随想录笔记-链表
最新发布
weixin_46321761的博客
08-26 431
1.核心是addAtIndex(int index, int val)；需要判断index,如果大于size,返回；如果
动态规划类型题目汇总及解析（持续更新）
2302_79366101的博客
08-24 618
Leetcode 1049. 最后一块石头的重量 IIpublic:int dp[N];int res=0;i++){j--){
x264 编码器 AArch64汇编系列：运动补偿之像素均值处理函数
人生只有一次，不妨大胆一点～～
08-26 103
x264 编码器 AArch64汇编系列：运动补偿之像素均值处理函数
编程之路：从挫折到突破的心路历程
图灵追幕者博客录
08-23 263
编程学习之路充满了挫折和挑战，但正是这些挫折和挑战，让我们不断成长，最终成为更好的自己。通过学会分析问题、借助工具与社区、分解问题、系统学习、调整心态、制定计划、寻求支持等方法，我们能够更好地克服挫折，实现突破。在这条路上，保持冷静与坚持，是我们走向成功的关键。希望我的分享能够为大家的编程之路点亮一盏希望之光，让我们在编程的世界中，一起前行，勇往直前！
BZOJ2839:集合计数(容斥,组合数学)
06-08
这个问题是一个比较经典的容斥原理的应用题目。我们可以考虑使用容斥原理来求解这个问题。具体来说，我们可以考虑求出所有集合的个数，然后减去至少包含一个特定元素的集合的个数，再加上至少包含两个特定元素的集合的个数，以此类推，直到加上包含所有特定元素的集合的个数。 对于一个大小为n的集合，其子集的个数为2^n。因此，所有集合的个数为2^n。现在我们考虑如何计算至少包含一个特定元素的集合的个数。我们可以将这个特定元素看作是一个元素，然后考虑其余n-1个元素组成的集合的个数，即2^(n-1)。因此，至少包含一个特定元素的集合的个数为2^(n-1)。同理，至少包含两个特定元素的集合的个数为C(2,n)*2^(n-2)，其中C(2,n)表示从n个元素中选取2个元素的组合数。 将以上结果代入容斥原理的公式中，即可得到最终的计数公式： sum((-1)^k*C(k,n)*2^(n-k),k=0,1,...,n) 其中，sum表示对k从0到n进行求和，C(k,n)表示从n个元素中选取k个元素的组合数，2^(n-k)表示剩余元素组成集合的个数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值