Uva220 Othello

最新推荐文章于 2022-10-13 15:48:21 发布
最新推荐文章于 2022-10-13 15:48:21 发布
阅读量1.2k 收藏
点赞数 1
分类专栏： 算法竞赛入门经典(第二版)-刘汝佳-第四章 函数与递归 文章标签： 函数 uva
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h1120023921/article/details/52119686
版权




1.输出格式注意 程序结束的结尾换行是否有多 

2.输出黑白棋子数的时候数字%2d输出

3.边界值注意

4.打印所有合法点的时候两点之间有空格 最有一个点输出没有空格

5.可用Udebug上的测试数据测试下（不全）

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
char board[8][8]={},current;
int up(char current,int i,int j)			//判断是否合法   //上 
{
    if(board[i-1][j]==current||board[i-1][j]=='-'||board[i][j]!='-')
    {
        return 0;
    }
    else
    {
        for(int m=i-2;m>=0;m--)
        {
            if(board[m][j]=='-')
                return 0;
            else if(board[m][j]==current)
                return 1;
        }
    }
    return 0;
}
int down(char current,int i,int j)        //下 
{
    if(board[i+1][j]==current||board[i+1][j]=='-'||board[i][j]!='-')
        return 0;
    else
    {
        for(int m=i+2;m<8;m++)
        {
            if(board[m][j]=='-')
                return 0;
            else if(board[m][j]==current)
                return 1;
        }
    }
    return 0;
}
int left(char current,int i,int j)				//左 
{
    if(board[i][j-1]==current||board[i][j-1]=='-'||board[i][j]!='-')
        return 0;
    else
    {
        for(int n=j-2;n>=0;n--)
        {
            if(board[i][n]=='-')
                return 0;
            else if(board[i][n]==current)
                return 1;
        }
    }
    return 0;
}
int right(char current,int i,int j)				//右 
{
    if(board[i][j+1]==current||board[i][j+1]=='-'||board[i][j]!='-')
        return 0;
    else
    {
        for(int n=j+2;n<8;n++)
        {
            if(board[i][n]=='-')
                return 0;
            else if(board[i][n]==current)
                return 1;
        }
    }
    return 0;
}
int leftup(char current,int i,int j)			//左上 
{
    if(board[i-1][j-1]==current||board[i-1][j-1]=='-'||board[i][j]!='-')
        return 0;
    else
    {
        for(int m=i-2,n=j-2;m>=0&&n>=0;m--,n--)
        {
            if(board[m][n]=='-')
                return 0;
            else if(board[m][n]==current)
                return 1;
        }
    }
    return 0;
}
int rightup(char current,int i,int j)			//右上 
{
    if(board[i-1][j+1]==current||board[i-1][j+1]=='-'||board[i][j]!='-')
        return 0;
    else
    {
        for(int m=i-2,n=j+2;m>=0&&n<8;m--,n++)
        {
            if(board[m][n]=='-')
                return 0;
            else if(board[m][n]==current)
                return 1;
        }
    }
    return 0;
}
int leftdown(char current,int i,int j)			//左下 
{
    if(board[i+1][j-1]==current||board[i+1][j-1]=='-'||board[i][j]!='-')
        return 0;
    else
    {
        for(int m=i+2,n=j-2;m<8&&n>=0;m++,n--)
        {
            if(board[m][n]=='-')
                return 0;
            else if(board[m][n]==current)
                return 1;
        }
    }
    return 0;
}
int rightdown(char current,int i,int j)			//右下 
{
    if(board[i+1][j+1]==current||board[i+1][j+1]=='-'||board[i][j]!='-')
        return 0;
    else
    {
        for(int m=i+2,n=j+2;m<8&&n<8;m++,n++)
        {
            if(board[m][n]=='-')
                return 0;
            else if(board[m][n]==current)
                return 1;
        }
    }
    return 0;
}
void num()                              //计算当前棋面黑白子的个数
{
    int B=0,W=0;
    for(int i=0;i<8;i++)
        for(int j=0;j<8;j++)
    {
        if(board[i][j]=='B') B++;
        if(board[i][j]=='W') W++;
    }
    printf("Black - %2d White - %2d\n",B,W);
}
void L(char current)                    //输出当前玩家所有合法操作
{
    int flag=0,temp=0,p=0;
    for(int i=0;i<8;i++)
    {
        for(int j=0;j<8;j++)
        {
            if(up(current,i,j)||down(current,i,j)||left(current,i,j)||right(current,i,j)||leftup(current,i,j)||rightup(current,i,j)||leftdown(current,i,j)||rightdown(current,i,j))
            {
                temp++;
            }
        }
    }
        for(int i=0;i<8;i++)
        {
        for(int j=0;j<8;j++)
        {
            if(up(current,i,j)||down(current,i,j)||left(current,i,j)||right(current,i,j)||leftup(current,i,j)||rightup(current,i,j)||leftdown(current,i,j)||rightdown(current,i,j))
            {
                flag=1;
                cout<<'('<<i+1<<','<<j+1<<')';
                if(p!=temp-1)
                {
                    cout<<' ';
                    p++;
                }

                else
                    p++;
            }
        }
        }

    if(flag==0)
    {
        cout<<"No legal move.";
    }
            cout<<endl;

}
int L2(char current)                    //判断当前玩家是否有合法操作
{
    for(int i=0;i<8;i++)
    {
        for(int j=0;j<8;j++)
        {
            if(up(current,i,j)||down(current,i,j)||left(current,i,j)||right(current,i,j)||leftup(current,i,j)||rightup(current,i,j)||leftdown(current,i,j)||rightdown(current,i,j))
            {
                return 1;
            }

        }
    }
    return 0;
}
void Mup(int r,int c)						//翻转棋子 
{
    board[r][c]=current;
    if(board[r-1][c]!=current&&board[r-1][c]!='-')
    {
        for(int m=r-2;m>=0;m--)
        {
            if(board[m][c]=='-')
            break;
			if(board[m][c]==current)
            {
                for(int p=r-1;p>=m;p--)
                    board[p][c]=current;
                break;
            }
        }
    }

}
void Mdown(int r,int c)
{
    board[r][c]=current;
    if(board[r+1][c]!=current&&board[r+1][c]!='-')
    {
        for(int m=r+2;m<8;m++)
        {
        	if(board[m][c]=='-')
        	break;
            if(board[m][c]==current)
            {
                for(int p=r+1;p<=m;p++)
                    board[p][c]=current;
                break;
            }
        }
    }
}
void Mleft(int r,int c)
{
    board[r][c]=current;
    if(board[r][c-1]!=current&&board[r][c-1]!='-')
    {
        for(int n=c-2;n>=0;n--)
        {
        	if(board[r][n]=='-')
        	break;
            if(board[r][n]==current)
            {
                for(int q=c-1;q>=n;q--)
                    board[r][q]=current;
                break;
            }
        }
    }
}
void Mright(int r,int c)
{
    board[r][c]=current;
    if(board[r][c+1]!=current&&board[r][c+1]!='-')
    {
        for(int n=c+2;n<8;n++)
        {
        	if(board[r][n]=='-')
        	break;
            if(board[r][n]==current)
            {
                for(int q=c+1;q<n;q++)
                {
                    board[r][q]=current;
                }
                break;
            }
        }
    }
}
void Mleftup(int r,int c)
{
    board[r][c]=current;
    if(board[r-1][c-1]!=current&&board[r-1][c-1]!='-')
    {
        for(int m=r-2,n=c-2;m>=0&&n>=0;m--,n--)
        {
        	if(board[m][n]=='-')
        	break;
            if(board[m][n]==current)
            {
                for(int p=r-1,q=c-1;p>m&&q>n;p--,q--)
                    board[p][q]=current;
                break;
            }
        }
    }
}
void Mrightup(int r,int c)
{
    board[r][c]=current;
    if(board[r-1][c+1]!=current&&board[r-1][c+1]!='-')
    {
        for(int m=r-2,n=c+2;m>=0&&n<8;m--,n++)
        {
        	if(board[m][n]=='-')
        	break;
            if(board[m][n]==current)
            {
                for(int p=r-1,q=c+1;p>m&&q<n;p--,q++)
                    board[p][q]=current;
                break;
            }
        }
    }
}
void Mleftdown(int r,int c)
{
    board[r][c]=current;
    if(board[r+1][c-1]!=current&&board[r+1][c-1]!='-')
    {
        for(int m=r+2,n=c-2;m<8&&n>=0;m++,n--)
        {
        	if(board[m][n]=='-')
        	break;
            if(board[m][n]==current)
            {
                for(int p=r+1,q=c-1;p<m&&q>n;p++,q--)
                    board[p][q]=current;
                break;
            }
        }
    }
}
void Mrightdown(int r,int c)
{
    board[r][c]=current;
    if(board[r+1][c+1]!=current&&board[r+1][c+1]!='-')
    {
        for(int m=r+2,n=c+2;m<8&&n<8;m++,n++)
        {
        	if(board[m][n]=='-')
        	break;
            if(board[m][n]==current)
            {
                for(int p=r+1,q=c+1;p<m&&q<n;p++,q++)
                    board[p][q]=current;
                break;
            }
        }
    }
}
void printboard()
{
    for(int i=0;i<8;i++)      //输出棋盘
    {
        for(int j=0;j<8;j++)
            cout<<board[i][j];
				cout<<endl;
    }
}
void M(char r,char c)
{
	
    r=r-'0'-1;c=c-'0'-1;            //将char型转为int型再-1让棋盘适配数组
    while(L2(current)==0)               //如果当前玩家没有合法操作则则切换游戏者
    {
        if(current=='B')
            current='W';
        else
            current='B';
    }
    Mleftup(r,c);
    Mup(r,c);Mdown(r,c);Mleft(r,c);Mright(r,c);Mrightup(r,c);Mleftdown(r,c);Mrightdown(r,c);
    num();
    if(current=='W')
        current='B';
    else
        current='W';    
}

int main()
{
    //freopen("c:\\test.txt","r",stdin);
    //freopen("c:\\out.txt","w",stdout);
    int T;
    cin>>T;
    while(T--)
    {
    for(int i=0;i<8;i++)      //输入棋盘
        for(int j=0;j<8;j++)
            cin>>board[i][j];

    cin>>current;             //当前玩家

    char command;
    while(cin>>command)             //输入命令
    {
        if(command=='L') L(current);            //打印合法操作
        if(command=='Q') break;
        if(command=='M')
        {
            char r,c;
            cin>>r>>c;
            M(r,c);
        }
    }
    
    printboard();
    if(T)
    cout<<endl;
    }
}



/*
Udebug上的测试数据 

10
--------
--------
--------
---WB---
---BW---
--------
--------
--------
W
L
M46
L
M34
L
M23
L
M47
L
M56
L
M57
L
M43
L
M33
L
M63
L
M64
Q
--------
--------
--------
---WB---
---BW---
--------
--------
--------
B
L
M56
L
M64
L
M33
L
M57
L
M74
L
M53
L
M42
L
M84
L
M63
L
M34
Q
--------
--------
--------
---WB---
---BW---
--------
--------
--------
W
L
M64
L
M63
L
M35
L
M34
L
M62
L
M26
L
M43
L
M52
L
M23
L
M25
Q
--------
--------
--------
---WB---
---BW---
--------
--------
--------
W
L
M35
L
M56
L
M64
L
M53
L
M63
L
M25
L
M46
L
M73
L
M66
L
M57
Q
--------
--------
--------
---WB---
---BW---
--------
--------
--------
W
L
M53
L
M63
L
M35
L
M52
L
M51
L
M41
L
M31
L
M36
L
M64
L
M34
Q
--------
--------
--------
---WB---
---BW---
--------
--------
--------
B
L
M34
L
M33
L
M65
L
M46
L
M36
L
M66
L
M43
L
M53
L
M22
L
M23
Q
--------
--------
--------
---WB---
---BW---
--------
--------
--------
W
L
M53
L
M65
L
M46
L
M52
L
M75
L
M76
L
M63
L
M35
L
M41
L
M47
Q
--------
--------
--------
---WB---
---BW---
--------
--------
--------
B
L
M43
L
M33
L
M34
L
M35
L
M25
L
M53
L
M36
L
M24
L
M63
L
M65
Q
--------
--------
--------
---WB---
---BW---
--------
--------
--------
B
L
M34
L
M53
L
M66
L
M56
L
M67
L
M35
L
M52
L
M33
L
M36
L
M62
Q
--------
--------
--------
---WB---
---BW---
--------
--------
--------
W
L
M64
L
M43
L
M35
L
M65
L
M75
L
M26
L
M42
L
M36
L
M46
L
M56
Q
*/


DoubleHI-I
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
UVA220 黑白棋 Othello
m0_73035684的博客
08-28 216
这个题很像我刚做过的那道蓝题，就是在二维平面某行某列，换句话说是，某个方向上找符合条件的连续的元素，应该是可以用递归做，不过我还没怎么学递归，就先用循环了，前面那道题领我入门，这道题做完算是对这一类模拟很熟练了，其实也很简单，一个while循环就行了，循环结束，保存的就是符合条件的点的后面一个（或者说外面一个）的坐标，可能是出界的坐标，可能是界内不符合条件的坐标，这时我们就可以拿它作为边界来进行处理了，花了32分钟过了，不过是我下午写了1个小时后吃顿饭回来重新写的，要是我真的有这么厉害就好了，...
UVa220 黑白棋
u012861792的博客
08-23 428
题目不难，玩过黑白棋的都懂，关键是看清题目输入要求，还有坑爹的输出格式。 之前做过中国象棋的题目，已经有了基础了，所以做起来不难。然后象棋就已经搞了四个方向了，结果黑白棋直接来了8个方向，每个方向都要判断，最后出现了这个超长的代码。。。。。 #include&amp;lt;cstring&amp;gt; #include&amp;lt;cstdio&amp;gt; #include&amp;lt;iostream&amp;gt; using...
UVA220黑白棋题目详解
weixin_63460193的博客
10-13 534
黑白棋题解：通俗易懂
UVA 1400
01-20 1673
题目：http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=4146 经典线段树。。真的很经典的一个题。但是我断断续续写了接近两天才AC。主要是找BUG。。很多东西没有考虑完全，就开始写了。 在那个没有思考完全的代码下修改，太蛋碎了。 主要存
基于Java实现的AI导论-Othello
毕业作品网站
06-16 510
如黑白棋，又称反棋（Reversi）、奥赛罗棋（Othello）等，游戏使用围棋的棋盘棋子，在8*8的棋盘上，黑白双方分别落棋，翻动对方的棋子，直到棋盘占满或无合法棋子可下，游戏结束，根据双方棋子数量判断胜负。算法分为两个函数执行，一个是初次决策的decide函数，其中又调用了递归函数miniMaxRecursor来执行后续层minimax值的计算。不同于分别计算min,max值，在这两个函数中使用了flag为+1和-1乘上节点分数来表示max和min的效果，这样就可以都用max的方法来计算，维护起来比较简
Othello_othello_MFC_
10-01
- `Othello.dsp`、`Othello.dsw`：这是项目文件，存储了项目的设置和配置信息，用于Visual Studio打开和管理项目。 3. **MFC应用开发流程** 开发奥赛罗游戏首先需要创建一个MFC对话框应用程序，然后设计并实现...
1.Othello_othello_
10-01
《Vue.js实现的Othello游戏详解》 Othello，又称为翻转棋或黑白棋，是一款策略性极强的双人对弈游戏。在这个项目中，开发者使用了流行的前端框架Vue.js来构建了一个在线的Othello游戏平台。Vue.js以其轻量级、易...
aa.rar_othello
09-14
黑白棋（Othello），又称翻转棋、反棋，是一款深受全球玩家喜爱的策略性棋类游戏。本篇将详细解析&quot;aa.rar_othello&quot;压缩包中提供的黑白棋源码，帮助读者深入理解其背后的逻辑和编程技巧。 首先，我们要明确源码的...
othello
03-05
&quot;Othello&quot;，在IT领域中通常指的是一个经典的棋盘游戏，也称为&quot;翻转棋&quot;或&quot;黑白棋&quot;。这个游戏由两个人玩，每人执一种颜色的棋子（通常是黑色和白色）。游戏的目标是通过策略性地放置棋子，使对方的棋子被夹在两枚己方...
BW.rar_othello_黑白棋
09-22
黑白棋，又叫反棋(Reversi)、奥赛罗棋(Othello)、苹果棋或翻转棋。黑白棋在西方和日本很流行。游戏通过相互翻转对方的棋子，最后以棋盘上谁的棋子多来判断胜负。 它的游戏规则简单，因此上手很容易，但是它的变化又...
Java Othello-开源
04-27
Java语言的客户端/服务器Othello游戏环境
220 - Othello java
weixin_40101530的博客
11-26 449
这题终于ac了,格式上有个大坑,如下: Black - 7 White - 6,这个东西如果数字是1位数,前面就是2个空格,如果是2位数,前面就是1个空格....题目又不说,多亏是照着udebug设置的格式,要不永远都ac不了 System.out.println(&quot;Black - &quot;+String.format(&quot;%2d&quot;,cha[1])+&quot; White - &quot;+String.forma...
UVA - 220 Othello
weixin_42547447的博客
11-29 659
传送门：UVA-220 思路很好想，写个对某一位置判别合法性的函数，输出个数的时候应该占三个位（这里presentation error了几次）。 AC代码：   #include&lt;iostream&gt; #include&lt;fstream&gt; using namespace std; char pq[10][10];//存储棋盘 char rev(char tmp){i...
uio(universal input/output)协议设想（3）紫外线（UVA,UVB）强度测量的手机外设
pcj2007的专栏
06-20 672
20200620 计划做一个控制成本20块的紫外线（UVA,UVB）强度测量的手机外设。 经过几天的摸索，有个初步的方案： 分两个阶段： 原型阶段1. USB+MCU单片机+UVA+B-sensor紫外线传感器 尺寸会尽量小，应该类似小U盘大。直接插入手机，像U盘一样，手机做显示。 把蓝牙连接手机的方案暂时性否掉。原因是用蓝牙有供电问题，成本控制上也有问题。 原型阶段2.USB+MCU单片机+UVA-sensor紫外线传感器+BLE无线蓝牙 有个困难点：外壳，希望互联网思维能解决这个问题。
UVA220
02-20 101
这道题需要好好总结一下：因为虽然一开始我的思路是正确的，但是实现的方法却极其的复杂 先贴上我的代码 //之前的思路是没有问题的，但是在实现上缺乏一点灵活性，没有做到足够的抽象 //需求： //输入 //list当前棋方所有合法的位置（只要有一个方向合法就可以） //move，先判断这个位置+方向是不是合法，如果合法就更新棋盘 //如果想要判断和更新同时进行 //退出这...
UVA - 220 Othello(黑白棋)
YiShi's Blog
11-21 3349
题目链接 说说 这种题做起来最难受了，思路上没什么难度，细节处理一大堆，一不小心就得wrong，这次还好，一气呵成，写好后稍加改动就过了。 这种题一般代码量是需要不少的，常常会有很多冗余的部分，所以在写的过程中就要怎样让接近的功能用一个函数去实现，尽力让代码充分利用，这样去想也许会多一点做它的动力了。 需要注意的地方，输出黑白棋子数量的时候，数字要格式化输出占两位(%2d) 代码#
刘汝佳紫书 uva220 解题报告
kyoma的博客
07-05 1579
没想到AC了好感动啊。。。 前面的那道象棋蜜汁WA把我搞的身心俱疲，又见到一个和棋有关的题就怂了啊 本来觉得会和象棋那题一样蜜汁WA的说，结果提交的时候看到presentation error整个心是紧了一下好吗！！简直是初恋的感觉啊！！ 结果这题输出及其坑爹。。。 输出注意： 1、打印有效点的时候每个点之间都有空格，但是最后一个点后面不能有 2、每个回合之间有空行（这个想必大家都会注
UVa220
herhuel3200
02-17 555
/*** UVa220 ***/#include <iostream>using namespace std; #define maxn 8 char table[maxn][maxn];inline void _L(char&); inline void _M(char&,int&,int&,int,int);int main() { int n,tow,tob,x,y; cha
othello python
最新发布
12-11
Othello 是一种棋类游戏，也叫做翻转棋。这个游戏是由两人轮流下棋，在一个8x8的棋盘上，以黑白两色代表双方进行对战。游戏的目标是通过落子来翻转对方的棋子，并占领更多的棋盘格子。 Python 是一种高级编程语言，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值