Othello UVA - 220

最新推荐文章于 2025-05-13 00:51:42 发布
最新推荐文章于 2025-05-13 00:51:42 发布
阅读量237 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： # 水题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/leekerian/article/details/84403387
本文分享了一段使用C++实现的Reversi（翻转棋）博弈算法代码，详细展示了如何通过遍历棋盘来判断合法落子位置，并实现了棋子的翻转逻辑。文章代码包括了棋盘状态更新、玩家交替、棋子计数等功能，适用于理解Reversi游戏规则及算法实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

过了udebug的所有数据以及各种数据但是就是wa不知道为什么 哎

只能先放着了 以后再来写写看把

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <algorithm>

using namespace std;

struct node 
{
    int x,y;
}num[111],num1[111];

int m1[8]={1,1,0,-1,-1,-1,0,1};
int m2[8]={0,1,1,1,0,-1,-1,-1};

bool judge(int x,int y)
{
    if(x>=1&&x<=8&&y>=1&&y<=8)
        return true;
    return false;
}

bool cmp(struct node a,struct node b)
{
    if(a.x==b.x)
        return a.y<b.y;
    return a.x<b.x;
}
char map[10][10];
    int map1[10][10];
int xuan;
int L(int fg)
{
    int ans=0;
    memset(map1,0,sizeof(map1));
                int cont=0;
                if(xuan==0)
                {
                    for(int i=1;i<=8;i++)
                    {
                        for(int j=1;j<=8;j++)
                        {
                            if(map[i][j]=='W')
                            {
                                int x1,y1;
                                for(int m=0;m<8;m++)
                                {
                                    int fg1=0;
                                    x1=i+m1[m];
                                    y1=j+m2[m];
                                    while(judge(x1,y1)&&map[x1][y1]=='B')
                                    {
                                        fg1=1;
                                        x1+=m1[m];
                                        y1+=m2[m];
                                    }
                                    if(judge(x1,y1)&&fg1==1&&map[x1][y1]=='-'&&map1[x1][y1]==0)
                                    {
                                        map1[x1][y1]=1;
                                        num[cont].x=x1;
                                        num[cont].y=y1;
                                        cont++;
                                    }
                                    
                                }
                            }
                        }
                    }
                }
                else if(xuan==1)
                {
                    for(int i=1;i<=8;i++)
                    {
                        for(int j=1;j<=8;j++)
                        {
                            if(map[i][j]=='B')
                            {
                                int x1,y1;
                                for(int m=0;m<8;m++)
                                {
                                    int fg1=0;
                                    x1=i+m1[m];
                                    y1=j+m2[m];
                                    while(judge(x1,y1)&&map[x1][y1]=='W')
                                    {
                                        fg1=1;
                                        x1+=m1[m];
                                        y1+=m2[m];
                                    }
                                    if(judge(x1,y1)&&fg1==1&&map[x1][y1]=='-'&&map1[x1][y1]==0)
                                    {
                                        map1[x1][y1]=1;
                                        num[cont].x=x1;
                                        num[cont].y=y1;
                                        cont++;
                                    }
                                   
                                }
                            }
                        }
                    }
                }
                //cout<<"!!!"<<cont<<endl;
                if(cont==0)
                {
                    if(fg==0)
                        cout<<"No legal move."<<endl;
                    ans=0;
                }
                else
                {
                    ans=1;
                    if(fg==0)
                    {
                        sort(num,num+cont,cmp);
                    for(int i2=0;i2<cont;i2++)
                    {
                    if(i2==0)
                        cout<<"("<<num[i2].x<<","<<num[i2].y<<")";
                    else
                        cout<<" ("<<num[i2].x<<","<<num[i2].y<<")";
                    }
                    cout<<endl;
                    }
                    
                }
                return ans;
}
int main()
{
    //freopen("out.txt","w",stdout);
    int n;
    cin>>n;
    int fff=0;
    while(n--)
    {
        if(fff!=0)
            cout<<endl;
        memset(map,'\0',sizeof(map));
        for(int i=1;i<=8;i++)
        {
            getchar();
            for(int j=1;j<=8;j++)
            {
                cin>>map[i][j];
            }
        }
        char str;
        while(1)
        {
            getchar();
            cin>>str;
            if(str=='Q')
            {
                fff++;
                for(int i=1;i<=8;i++)
                {
                    for(int j=1;j<=8;j++)
                    {
                        cout<<map[i][j];
                    }
                    cout<<endl;
                }
                
                break;
            }
            else if(str=='W')
            {
                xuan=0;
                continue;
            }
            else if(str=='B')
            {
                xuan=1;
                continue;
            }
            else if(str=='L')
            {
                int LL=L(0);
            }
            else if(str=='M')
            {
                int pp=L(1);
                if(pp==0)
                {
                    if(xuan==0)
                        xuan=1;
                    else if(xuan==1)
                        xuan=0;
                }
                char s[2];
                scanf("%s",s);
                //puts(s);
                int x1,y1;
                x1=s[0]-'0';
                y1=s[1]-'0';
                if(xuan==0)
                {
                    map[x1][y1]='W';
                    int cont2=0;
                    for(int i=0;i<8;i++)
                    {
                        int x2,y2;
                        x2=x1+m1[i];
                        y2=y1+m2[i];
                        int fg2=0;
                        while(judge(x2,y2)&&map[x2][y2]=='B')
                        {
                            fg2=1;
                            num1[cont2].x=x2;
                            num1[cont2].y=y2;
                            x2+=m1[i];
                            y2+=m2[i];
                            //cout<<x2<<"!@#"<<y2<<endl;
                            cont2++;
                        }
                        if(judge(x2,y2)&&fg2==1&&map[x2][y2]=='W')
                        {
                            
                            for(int i1=0;i1<cont2;i1++)
                            {
                                //cout<<"!!!"<<num1[i1].x<<"!!"<<num1[i1].y<<endl;
                                map[num1[i1].x][num1[i1].y]='W';
                            }
                        }
                        else
                            cont2=0;
                    }
                    xuan=1;
                    int a1=0;
                int b1=0;
                for(int j1=1;j1<=8;j1++)
                {
                    for(int j2=1;j2<=8;j2++)
                    {
                        if(map[j1][j2]=='B')
                            a1++;
                        else if(map[j1][j2]=='W')
                            b1++;
                    }
                }
                printf("Black - %2d White - %2d\n",a1,b1);
             
                   
                }
                else if(xuan==1)
                {
                    map[x1][y1]='B';
                    int cont2=0;
                    for(int i=0;i<8;i++)
                    {
                        int x2,y2;
                        x2=x1+m1[i];
                        y2=y1+m2[i];
                        int fg2=0;
                        while(judge(x2,y2)&&map[x2][y2]=='W')
                        {
                            fg2=1;
                            num1[cont2].x=x2;
                            num1[cont2].y=y2;
                            x2+=m1[i];
                            y2+=m2[i];
                            cont2++;
                        }
                        if(judge(x2,y2)&&fg2==1&&map[x2][y2]=='B')
                        {
                            for(int i1=0;i1<cont2;i1++)
                            {
                                map[num1[i1].x][num1[i1].y]='B';
                            }
                        }
                        else
                            cont2=0;
                    }
                    xuan=0;
                    int a1=0;
                int b1=0;
                for(int j1=1;j1<=8;j1++)
                {
                    for(int j2=1;j2<=8;j2++)
                    {
                        if(map[j1][j2]=='B')
                            a1++;
                        else if(map[j1][j2]=='W')
                            b1++;
                    }
                }
                printf("Black - %2d White - %2d\n",a1,b1);
               
                }
                
            }
            
        }
    }
    return 0;
}

 

UVA - 220 Othello
weixin_42547447的博客
11-29 775
传送门：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...
0016 Othello UVA - 220 算法竞赛入门经典系列源码解析
算法竞赛入门，越专注，越成功。
11-05 249
0016 Othello UVA - 220 算法竞赛入门经典系列源码解析
UVA - 220 - Othello
weixin_30457551的博客
01-26 153
最害怕这种下棋的题了，情况特别多，考差细节特别多，当时没做，现在翻过头来再看一下，顺便复习一下基础。 这道题要注意格式，输出统计黑白棋子数的时候，数要占两位。其他都是普通的思路，顺着题目要求即可。 寒假刚刚开始，是提高自我的好时间，希望自己能利用起来。 #include <bits/stdc++.h> using namespace std; char tab[...
DigXY V1.0.1数据提取工具：高效数字化图像曲线数据
最新发布
gitblog_06738的博客
05-13 556
DigXY V1.0.1数据提取工具：高效数字化图像曲线数据 【下载地址】DigXYV1.0.1数据提取工具 DigXY V1.0.1是一款高效实用的数据提取工具，专为从图片中提取曲线数据而设计。它能够将图像中的曲线快速数字化，无论是线性还是非线性图形，都能精准处理。工具操作界面简洁直观，用户无需复杂学习即可轻松上手。通...
UVA - 220 Othello(黑白棋)
YiShi's Blog
11-21 3440
题目链接 说说 这种题做起来最难受了，思路上没什么难度，细节处理一大堆，一不小心就得wrong，这次还好，一气呵成，写好后稍加改动就过了。 这种题一般代码量是需要不少的，常常会有很多冗余的部分，所以在写的过程中就要怎样让接近的功能用一个函数去实现，尽力让代码充分利用，这样去想也许会多一点做它的动力了。 需要注意的地方，输出黑白棋子数量的时候，数字要格式化输出占两位(%2d) 代码#
UVA - 220 Othello（黑白棋）
葉蕖的博客
10-09 1332
就是模拟。。 代码： #include &lt;bits/stdc++.h&gt; using namespace std; int xx[] = {-1,-1,-1, 1,1,1,0, 0}; int yy[] = {-1, 0, 1,-1,0,1,1,-1}; char mmp[10][10]; int fff[2][10][10]; void move(int x, int y, int ...
UVa 220 - Othello
_____
08-13 1837
一道黑白棋的模拟，难度上来说不算难，属于比较麻烦的……因为要八个方向去找去操作，没啥好说的，就是模拟。
UVA220 黑白棋 Othello
Mark_mgx的博客
09-27 669
题目 你的任务是模拟黑白棋游戏的进程。黑白棋的规则为:黑白双方轮流放棋子,每次必 须让新放的棋子“夹住”至少一枚对方棋子,然后把所有被新放棋子“夹住”的对方棋子 替换成己方棋子。一段连续(横、竖或者斜向)的同色棋子被“夹住”的条件是两端都是 对方棋子(不能是空位)。如图所示,白棋有6个合法操作,分别为(2,3),(3,3),(3,5),(6,2),(7,3),(7,4)。选择在(7,3)放白棋后变成如图所示效果(注意有竖向和斜向的共两枚黑棋变白)。注意(4,6)的黑色棋子虽然被夹住,但不是被新放的棋子夹住
UVA 题目难度分级列表
qq_44929357的博客
04-29 1451
UVA 题目难度分级列表
uva 220 Othello
qq_33901573的博客
05-18 400
未A，但是测试了好多数据，没有找出错误。#include #include #include using namespace std; using namespace std; char board[10][10]; char FirstStep; int adj[9][9]; int countW=0,countB=0; int num=0; int n; //存放合法路径 typedef st
DIGXY1.1.1
05-27
可提取坐标，是一款可随意提取图片中曲线上的数据等（十分好用），可以将图片中的曲线数字化
uva220 Othello
qq_41856690的博客
07-15 273
黑白棋题意就是模拟下棋，L：查询当前合法的下子位置，若无，特殊输出，若有，输出在一行。MXX：先判当前棋手是否有合法的下子位置，若无自动换人，然后下子，再换人（再换人这部分题目里没有说但是根据测试数据2可以推断出来）。        若有合法位置，下子，换人。        两种都要输出下子结束后双方棋的个数，注意格式为“Black - %2d White - %2d”。Q：结束当前棋局并打印棋盘...
Uva 220 Othello
Green_Days
02-03 421
又是一个黑白棋的大模拟，这种棋类模拟通常分为多个函数实现能大大减少代码量。#include #include #include using namespace std; #define N 15 char mat[N][N],player[2],com[4]; bool state; typedef struct node{ int x,y; }; bool judge(in
UVa 220 Othello
launch8的博客
06-03 289
这个题的思路也比较清晰，依然花了1个小时才把代码写出来，好在bug不多 //Othello #include #include using namespace std; char b[10][10]; int check(char type,int x,int y); char* move(int dir, int num,int x,int y); void M(char type, int
算法竞赛入门经典第四章习题4-3 Othello UVA - 220
Bendaai的博客
01-05 367
习题4-3 https://vjudge.net/problem/UVA-220#include<iostream> #include<string> #include<cstring> #pragma warning(disable:4996) using namespace std; string s[9]; int turn; int Qi_n[2]; char Qi[2] = {'B',
Uva220 Othello
h1120023921的博客
08-04 1306
可用Udebug上的测试数据测试下（不全） 1.输出格式注意 程序结束的结尾换行是否有多  2.输出黑白棋子数的时候数字%2d输出 3.边界值注意 4.打印所有合法点的时候两点之间有空格 最有一个点输出没有空格 #include #include #include using namespace std; char board[8][8]={},current; int up(char current,int i,in
UVA - 220 Othello(模拟)
Chook_lxk的博客
01-28 306
点击打开题目链接 一秒钟想思路，一下午调BUG 注意的地方： 1.输出格式最后不要多加空行。 2.坐标之间一个空格间隔，行尾没空格 3.棋子数的输出%2d 4.No legal move.(我忘了点，udebug样例全过了,找了半天才找出来TAT) AC代码： #include #include #include using namespace std; int mp[10
othello-alpha-beta：简易实现Othello游戏Alpha-Beta剪枝算法
资源摘要信息: "Othello-Alpha-Beta：用于Othello游戏的简单Alpha-Beta剪枝算法实现" Othello游戏，又称黑白棋或Reversi，是一种经典的两人棋盘游戏，由于其策略性和计算复杂性，成为计算机程序设计中常用的算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值