220 - Othello

最新推荐文章于 2019-02-04 22:49:29 发布
最新推荐文章于 2019-02-04 22:49:29 发布
阅读量700 收藏
点赞数
分类专栏： uva解题报告 文章标签： acm uva
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weizhuwyzc000/article/details/43482349
版权

写了382行我也是醉了。。。。不过很多部分只是粘贴而已，基本思路就是按照题目说的做

需要注意的是：

1.两组数据间一个空行

2.printf("Black -%3d White -%3d\n",B,W);要这么写；

3.在L命令下要这样输出空格  ： if(AC)
                        printf(" ");
                        AC=1;
                    printf("(%d,%d)",i,j);
                         

#include<stdio.h>
#include<string.h>
char s[20][20];
char ens[10],ans[10];
void LL(char b,char w){
    int i,j,n,m,maxnn=0,AC=0;
        for(i=1;i<=8;i++)
        for(j=1;j<=8;j++){
                if(s[i][j]=='-'){
            if(s[i-1][j]==w){
                int kase=0;
                for(n=i-1;n>=1;n--){
                    if(s[n][j]!=w&&s[n][j]!=b)
                        break;
                if(s[n][j]==b){
                    kase=1;break;
                }
                }
                if(kase!=0){
                        if(AC)
                        printf(" ");
                        AC=1;
                    printf("(%d,%d)",i,j);
                        maxnn++;
                        continue;
                }
            }
            if(s[i+1][j]==w){
                int kase=0;
                for(n=i+1;n<=8;n++){
                    if(s[n][j]!=w&&s[n][j]!=b)
                        break;
                if(s[n][j]==b){
                    kase=1;break;
                }
                }
                if(kase!=0){
                        if(AC)
                        printf(" ");
                        AC=1;
                    printf("(%d,%d)",i,j);
                        maxnn++;
                        continue;
                }
            }
            if(s[i][j-1]==w){
                int kase=0;
                for(n=j-1;n>=1;n--){
                    if(s[i][n]!=w&&s[i][n]!=b)
                        break;
                if(s[i][n]==b){
                    kase=1;break;
                }
                }
                if(kase!=0){
                        if(AC)
                        printf(" ");
                        AC=1;
                    printf("(%d,%d)",i,j);
                        maxnn++;
                        continue;
                }
            }
            if(s[i][j+1]==w){
                int kase=0;
                for(n=j+1;n<=8;n++){
                    if(s[i][n]!=w&&s[i][n]!=b)
                        break;
                if(s[i][n]==b){
                    kase=1;break;
                }
                }
                if(kase!=0){
                        if(AC)
                        printf(" ");
                        AC=1;
                    printf("(%d,%d)",i,j);
                        maxnn++;
                        continue;
                }
            }
            if(s[i-1][j-1]==w){
                int kase=0;m=j-1;
                for(n=i-1;n>=1;n--){
                    if(s[n][m]!=w&&s[n][m]!=b)
                        break;
                    if(s[n][m]==b){
                        kase=1;break;
                    }
                    m--;
                }
               if(kase!=0){
                    if(AC)
                        printf(" ");
                        AC=1;
                    printf("(%d,%d)",i,j);
                        maxnn++;
                        continue;
                }
            }
            if(s[i+1][j+1]==w){
                int kase=0;m=j+1;
                for(n=i+1;n<=8;n++){
                    if(s[n][m]!=w&&s[n][m]!=b)
                        break;
                    if(s[n][m]==b){
                        kase=1;break;
                    }
                    m++;
                }
                if(kase!=0){
                        if(AC)
                        printf(" ");
                        AC=1;
                    printf("(%d,%d)",i,j);
                        maxnn++;
                        continue;
                }
            }
            if(s[i-1][j+1]==w){
                int kase=0;m=j+1;
                for(n=i-1;n>=1;n--){
                    if(s[n][m]!=w&&s[n][m]!=b)
                        break;
                    if(s[n][m]==b){
                        kase=1;break;
                    }
                    m++;
                }
                   if(kase!=0){
                        if(AC)
                        printf(" ");
                        AC=1;
                        printf("(%d,%d)",i,j);
                            maxnn++;
                            continue;
                    }
            }
            if(s[i+1][j-1]==w){
                int kase=0;m=j-1;
                for(n=i+1;n<=8;n++){
                    if(s[n][m]!=w&&s[n][m]!=b)
                        break;
                    if(s[n][m]==b){
                        kase=1;break;
                    }
                    m--;
                }
                if(kase!=0){
                        if(AC)
                        printf(" ");
                        AC=1;
                    printf("(%d,%d)",i,j);
                        maxnn++;
                        continue;
                }
            }
        }
        }
        if(maxnn==0)
            printf("No legal move.\n");
            else printf("\n");
}
int  MM(int r,int c,char b,char w){
    int i,j,n,m,maxnn=0;
            if(s[r][c]=='-'){
            if(s[r-1][c]==w){
                int kase=0,x,y;
                for(n=r-1;n>=1;n--){
                    if(s[n][c]!=w&&s[n][c]!=b)
                        break;
                if(s[n][c]==b){
                    kase=1;y=c;x=n+1;break;
                }
                }
                if(kase!=0){
                        s[r][c]=b;
                    for(m=x;m<=r-1;m++)
                        s[m][c]=b;
                        maxnn++;
                }
            }
            if(s[r+1][c]==w){
                int kase=0,x,y;
                for(n=r+1;n<=8;n++){
                    if(s[n][c]!=w&&s[n][c]!=b)
                        break;
                if(s[n][c]==b){
                    kase=1;y=c;x=n-1;break;
                }
                }
                if(kase!=0){
                        s[r][c]=b;
                    for(m=r+1;m<=x;m++)
                        s[m][c]=b;
                        maxnn++;
                }
            }
            if(s[r][c-1]==w){
                int kase=0,x,y;
                for(n=c-1;n>=1;n--){
                    if(s[r][n]!=w&&s[r][n]!=b)
                        break;
                if(s[r][n]==b){
                    kase=1;y=c;x=n+1;break;
                }
                }
                if(kase!=0){
                        s[r][c]=b;
                    for(m=x;m<=c-1;m++)
                        s[r][m]=b;
                        maxnn++;
                }
            }
            if(s[r][c+1]==w){
                int kase=0,x,y;
                for(n=c+1;n<=8;n++){
                    if(s[r][n]!=w&&s[r][n]!=b)
                        break;
                if(s[r][n]==b){
                    kase=1;y=c;x=n-1;break;
                }
                }
                if(kase!=0){
                        s[r][c]=b;
                    for(m=c+1;m<=x;m++)
                        s[r][m]=b;
                        maxnn++;
                }
            }
        if(s[r+1][c+1]==w){
                int kase=0,x,y;m=c+1;
                for(n=r+1;n<=8;n++){
                    if(s[n][m]!=w&&s[n][m]!=b)
                        break;
                    if(s[n][m]==b){
                        kase=1;x=n-1;y=m-1;break;
                    }
                    m++;
                }
                if(kase!=0){
                        s[r][c]=b;
                        m=c+1;
                    for(n=r+1;n<=x;n++){
                        s[n][m]=b;
                        m++;
                    }
                    maxnn++;
                }
            }
            if(s[r-1][c-1]==w){
                int kase=0,x,y;m=c-1;
                for(n=r-1;n>=1;n--){
                    if(s[n][m]!=w&&s[n][m]!=b)
                        break;
                    if(s[n][m]==b){
                        kase=1;x=n+1;y=m+1;break;
                    }
                    m--;
                }
                if(kase!=0){
                        s[r][c]=b;
                        m=y;
                    for(n=x;n<=r-1;n++){
                        s[n][m]=b;
                        m++;
                    }
                    maxnn++;
                }
            }
            if(s[r-1][c+1]==w){
                int kase=0,x,y;m=c+1;
                for(n=r-1;n>=1;n--){
                    if(s[n][m]!=w&&s[n][m]!=b)
                        break;
                    if(s[n][m]==b){
                        kase=1;x=n+1;y=m-1;break;
                    }
                    m++;
                }
                if(kase!=0){
                        s[r][c]=b;
                        m=y;
                    for(n=x;n<=r-1;n++){
                        s[n][m]=b;
                        m--;
                    }
                    maxnn++;
                }
            }
            if(s[r+1][c-1]==w){
                int kase=0,x,y;m=c-1;
                for(n=r+1;n<=8;n++){
                    if(s[n][m]!=w&&s[n][m]!=b)
                        break;
                    if(s[n][m]==b){
                        kase=1;x=n-1;y=m+1;break;
                    }
                    m--;
                }
                if(kase!=0){
                        s[r][c]=b;
                        m=c-1;
                    for(n=r+1;n<=x;n++){
                        s[n][m]=b;
                        m--;
                    }
                    maxnn++;
                }
            }
}
            if(maxnn==0)
                return 0;
            else return 1;
}
int main(){
    int T,i,j,n,maxn=0;
    scanf("%d",&T);
    while(T--){
            memset(s,'0',sizeof(s));
            char s1[20];
            if(maxn)
            printf("\n");
        maxn=1;
        for(i=1;i<=8;i++){
            scanf("%s",s1);
            for(j=0;j<8;j++)
                s[i][j+1]=s1[j];
        }
        scanf("%s",ens);
        while(1){
            scanf("%s",ans);
            if(ans[0]=='L'){
                char b,w;
                b='B';w='W';
                if(ens[0]=='B') LL(b,w);
                    else LL(w,b);
            }
            else if(ans[0]=='M'){
                int r,c;
                r=ans[1]-'0'; c=ans[2]-'0';
                char b,w;
                b='B';w='W';
                if(ens[0]=='B'){
                    if(MM(r,c,b,w)!=0)
                       ens[0]='W';
                    else{
                        MM(r,c,w,b);
                        ens[0]='B';
                    }
                }
                else{
                    if(MM(r,c,w,b)!=0)
                        ens[0]='B';
                        else{
                            MM(r,c,b,w);
                            ens[0]='W';
                }
            }
                int W=0,B=0;
                for(i=1;i<=8;i++)
                for(j=1;j<=8;j++){
                    if(s[i][j]=='W')
                        W++;
                    if(s[i][j]=='B')
                        B++;
                }
                printf("Black -%3d White -%3d\n",B,W);
            }
            else if(ans[0]=='Q')
                break;
        }
        for(i=1;i<=8;i++)
        for(j=1;j<=8;j++){
            if(j==8)
            printf("%c\n",s[i][j]);
            else
                printf("%c",s[i][j]);
        }
    }
    return 0;
}

AC_Arthur
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Snake--Tetris--Othello.zip_othello_黑白Tetris
09-23
在本压缩包“Snake--Tetris--Othello.zip_othello_黑白Tetris”中，包含三个经典游戏的C语言实现：贪吃蛇（Snake）、俄罗斯方块（Tetris）以及黑白棋（Othello）。这些游戏不仅在计算机科学领域具有广泛的认识，而且...
读Ludo Hashing: Compact, Fast, and Dynamic Key-value Lookups for Practical Network Systems论文笔记
syuichihann的博客
01-29 273
一种新的键值查找设计，在已知的紧凑型查找解决方案（包括Cuckoo）中，其空间最小（对于l位值，每个键值项为3.76 + 1.05l位）和Bloomier完美哈希。支持快速查找，快速更新和并发写入/读取。与现有的动态解决方案相比，Ludo Hashing实际上节省了40％至80％以上的内存成本。它仅花费几个GB的内存即可存储10亿个键值项目，并实现了高查找吞吐量：在具有多个线程的单个节点上，每秒超过6500万次查询。 简介 ludo hashing通过删除the key storage同时在值上保持较低的放
《算法竞赛入门经典》习题4-3　黑白棋（Othello, ACM、ICPC World Finals 1992, UVa220）
Alex
02-04 1957
原题及翻译 Othello is a game played by two people on an 8 x 8 board, using disks that are white on one side and black on the other. 奥赛罗是一个由两个人在一个8×8的棋盘上玩的游戏，使用的是一面是白色，另一面是黑色的棋子。 One player places disks wit...
Redis2.2.2源码学习——dict中的hashtable扩容和rehash
ordeder的专栏
10-17 4903
dict是Redis的hash表结构，所有类型的元素都可以依据key值计算hashkey，然后将元素插入到dict的某个hash链上（采用拉链发解决hash冲突）。其中，dict的总hashtable的扩容是dict很重要的部分。Redis的“管家”函数serverCron会依据一定的算法（dict中的used与size的比值）判定是否开始进行hashtable的扩容。扩容之后，hashtalbe的长度将变长，那么hashtalbe的masksize与原来的makssize就不同了，那么计算出的hashke
HASH函数
rongwenbin的专栏
12-17 832
HASH函数 计算理论中，没有Hash函数的说法，只有单向函数的说法。所谓的单向函数，是一个复杂的定义，大家可以去看计算理论或者密码学方面的数据。用“人类”的语言描述单向函数就是：如果某个函数在给定输入的时候，很容易计算出其结果来；而当给定结果的时候，很难计算出输入来，这就是单项函数。各种加密函数都可以被认为是单向函数的逼近。Hash函数（或者成为散列函数）也可以看成是单向函数的一个
为什么要用Redis，Redis有哪些优缺点？Redis如何实现扩容？
qiuchaoxi的博客
07-12 6335
优点： 1 读写性能优异，从内存当中进行IO读写速度快。 2 支持数据持久化，支持AOF和RDB两种持久化方式(由于Redis的数据都存放在内存中，如果没有配置持久化，redis重启后数据就全丢失了，于是需要开启redis的持久化功能，将数据保存到磁 盘上，当redis重启后，可以从磁盘中恢复数据。redis提供两种方式进行持久化，一种是RDB持久化:指在指定的时间间隔内将内存中的数据集快照写...
node-othello-lib:node-othello 的黑白棋游戏逻辑
05-30
《深入解析Node.js黑白棋游戏库：node-othello-lib》 在JavaScript的世界里，有许多优秀的库用于构建各种游戏，其中node-othello-lib是一个专为Node.js平台设计的黑白棋（也称翻转棋）游戏逻辑库。本文将详细探讨这...
c-othello
03-27
《C++实现的othello游戏详解》 &quot;othello&quot;，又称为翻转棋或黑白棋，是一款策略性极强的双人对弈游戏。在编程领域，将othello游戏用C++语言实现是一项常见的练习，它能很好地检验开发者对于算法的理解、数据结构的...
projet-othello:Projet Appli ObjetPython-Jeu Othello
03-15
在这个项目&quot;projet-othello: Projet Appli Objet Python-Jeu Othello&quot;中，开发者使用Python编程语言构建了一个完整的奥赛罗游戏应用。这个项目对于学习Python编程、对象导向编程以及游戏开发的初学者来说，具有很高...
基于Java实现的AI导论-Othello.zip
06-16
资源包含文件：设计报告word+源码 算法分为两个函数执行，一个是初次决策的decide函数，其中又调用了递归函数miniMaxRecursor来执行后续层minimax值的计算。不同于分别计算min,max值，在这两个函数中使用了flag为+1...
othello 游戏
12-04
此游戏名称有 苹果棋，奥瑟罗，reversi 实现人机对战，内有详尽的代码注释，使用c++编写，vs2008工作环境是console application
The Hash
wj971hewei的专栏
12-31 804
Abstract I offer you a new hash function for hash table lookup that isfaster and more thorough than the one you are using now. I also giveyou a way to verify that it is more thorough. All the text
C++——黑白棋（基础模块）
chengchencheng的博客
11-29 2212
 黑白棋（基础模块） 时限：1000ms 内存限制：10000K 总时限：3000ms 描述： 相信大家对于黑白棋已经了如指掌了，下面我们来编写一些更有挑战性的模块。对于棋盘的某种状态来说，可能有很多处都可以下子，也可能只有一处，甚至无处下子。我们需要你编写程序计算对于将要下某种颜色当前棋盘状态共有多少处可以落子。 输入： 首先读入的是当前棋盘的状态，共8行，每行8个数
uva220 Othello
qq_41856690的博客
07-15 209
黑白棋题意就是模拟下棋，L：查询当前合法的下子位置，若无，特殊输出，若有，输出在一行。MXX：先判当前棋手是否有合法的下子位置，若无自动换人，然后下子，再换人（再换人这部分题目里没有说但是根据测试数据2可以推断出来）。        若有合法位置，下子，换人。        两种都要输出下子结束后双方棋的个数，注意格式为“Black - %2d White - %2d”。Q：结束当前棋局并打印棋盘...
Uva220 Othello
h1120023921的博客
08-04 1237
可用Udebug上的测试数据测试下（不全） 1.输出格式注意 程序结束的结尾换行是否有多  2.输出黑白棋子数的时候数字%2d输出 3.边界值注意 4.打印所有合法点的时候两点之间有空格 最有一个点输出没有空格 #include #include #include using namespace std; char board[8][8]={},current; int up(char current,int i,in
Othello
Rookie的博客
11-27 431
UVa 220 这道题体现的就是操作和题目的理解能力， 操作其实不难，主要是要理解题目，输出的 时候注意个数就可以了，在输出白色和黑色有 多少个时，每个数字占两位(%2d)，能走的坐标 只有中间有一个空格，换行是每组数据之间一个 换行，当一方在某个坐标上下棋时，如果不能使 对方换颜色，那么就变为对方走，每次下子后， 下棋人变化，其他的就是一个个操作就行了。 #in
220:Othello
diaosuiwa6230的博客
04-13 124
Othello我的这道题的代码还是比较简洁的哈哈。version 1:#include<cstdio> #include<cstring> using namespace std; int n,wn,bn; int dxs[3] = {0,1,-1}; int dys[3] = {0,1,-1}; char c,gamer,cmd...
othello python
最新发布
12-11
Othello 是一种棋类游戏，也叫做翻转棋。这个游戏是由两人轮流下棋，在一个8x8的棋盘上，以黑白两色代表双方进行对战。游戏的目标是通过落子来翻转对方的棋子，并占领更多的棋盘格子。 Python 是一种高级编程语言，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值