UVa 220 - Othello（模拟）

最新推荐文章于 2019-07-19 19:18:30 发布
最新推荐文章于 2019-07-19 19:18:30 发布
阅读量592 收藏
点赞数
分类专栏： UVa 算法竞赛入门经典（第二版）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuziye0327/article/details/44207387
版权

一道纯模拟题， 曾经写了3次， 一直WA， 完全找不出错， 寒假的时候又是找不出来错， 然后。。。惊奇地发现多了个空行， 去掉， AC。。。真是醉了。


#include <iostream>
#include <cstdio>
#include <cstring>

#define MAXN 10

using namespace std;

int legal[MAXN][MAXN];
char chess, disk[MAXN][MAXN];

char other_chess() {
    return chess == 'B' ? 'W' : 'B';
}

bool check() {
    memset(legal, 0, sizeof(legal));
    int p, q;
    char other = other_chess();
    bool ok = false;
    for(int i = 0; i < MAXN; i++)              //搜索当前棋子所在的位置
        for(int j = 0; j < MAXN; j++)
            if(disk[i][j] == chess) {
                if(i - 1 >= 0&& j - 1 >= 0&& disk[i - 1][j - 1] == other) { //如果左上有其他子
                    p = i - 1;
                    q = j - 1;
                    while(p >= 0&& q >= 0) {
                        if(disk[p][q] == other) {p--; q--; continue;}
                        if(disk[p][q] == chess) break;
                        if(disk[p][q] == '-') {legal[p][q] = 1; ok = true; break;}
                    }
                }
                if(i - 1 >= 0&& disk[i - 1][j] == other) {                  //正上
                    p = i - 1;
                    q = j;
                    while(p >= 0) {
                        if(disk[p][q] == other) {p--; continue;}
                        if(disk[p][q] == chess) break;
                        if(disk[p][q] == '-') {legal[p][q] = 1; ok = true; break;}
                    }
                }
                if(i - 1 >= 0&& j + 1 < 8&& disk[i - 1][j + 1] == other) {  //右上
                    p = i - 1;
                    q = j + 1;
                    while(p >= 0&& q < 8) {
                        if(disk[p][q] == other) {p--; q++; continue;}
                        if(disk[p][q] == chess) break;
                        if(disk[p][q] == '-') {legal[p][q] = 1; ok = true; break;}
                    }
                }
                if(j + 1 < 8&& disk[i][j + 1] == other) {                      //右
                    p = i;
                    q = j + 1;
                    while(q < 8) {
                        if(disk[p][q] == other) {q++; continue;}
                        if(disk[p][q] == chess) break;
                        if(disk[p][q] == '-') {legal[p][q] = 1; ok = true; break;}
                    }
                }
                if(i + 1 < 8&& j + 1 < 8&& disk[i + 1][j + 1] == other) {          //右下
                    p = i + 1;
                    q = j + 1;
                    while(p < 8&& q < 8) {
                        if(disk[p][q] == other) {p++; q++; continue;}
                        if(disk[p][q] == chess) break;
                        if(disk[p][q] == '-') {legal[p][q] = 1; ok = true; break;}
                    }
                }
                if(i + 1 < 8&& disk[i + 1][j] == other) {               //下
                    p = i + 1;
                    q = j;
                    while(p < 8) {
                        if(disk[p][q] == other) {p++; continue;}
                        if(disk[p][q] == chess) break;
                        if(disk[p][q] == '-') {legal[p][q] = 1; ok = true; break;}
                    }
                }
                if(i + 1 < 8&& j - 1 >= 0&& disk[i + 1][j - 1] == other) {  //左下
                    p = i + 1;
                    q = j - 1;
                    while(p < 8&& q >= 0) {
                        if(disk[p][q] == other) {p++; q--; continue;}
                        if(disk[p][q] == chess) break;
                        if(disk[p][q] == '-') {legal[p][q] = 1; ok = true; break;}
                    }
                }
                if(j - 1 >= 0&& disk[i][j - 1] == other) {             //左
                    p = i;
                    q = j - 1;
                    while(q >= 0) {
                        if(disk[p][q] == other) {q--; continue;}
                        if(disk[p][q] == chess) break;
                        if(disk[p][q] == '-') {legal[p][q] = 1; ok = true; break;}
                    }
                }
            }
    return ok;
}

void change_chess(int const x, int const y) {
    int i, j, p, q;
    char other = other_chess();
    if(x - 1 >= 0&& y - 1 >= 0&& disk[x - 1][y - 1] == other) {  //左上
        i = p = x - 1;
        j = q = y - 1;
        while(i >= 0&& j >= 0) {
            if(disk[i][j] == other) {i--; j--; continue;}
            if(disk[i][j] == '-') break;
            if(disk[i][j] == chess) {
                while(p != i&& q != j)
                    disk[p--][q--] = chess;
                break;
            }
        }
    }
    if(x - 1 >= 0&& disk[x - 1][y] == other) {  //上
        i = p = x - 1;
        j = q = y;
        while(i >= 0) {
            if(disk[i][j] == other) {i--; continue;}
            if(disk[i][j] == '-') break;
            if(disk[i][j] == chess) {
                while(p != i)
                    disk[p--][q] = chess;
                break;
            }
        }
    }
    if(x - 1 >= 0&& y + 1 < 8&& disk[x - 1][y + 1] == other) {  //右上
        i = p = x - 1;
        j = q = y + 1;
        while(i >= 0&& j < 8) {
            if(disk[i][j] == other) {i--; j++; continue;}
            if(disk[i][j] == '-') break;
            if(disk[i][j] == chess) {
                while(p != i&& q != j)
                    disk[p--][q++] = chess;
                break;
            }
        }
    }
    if(y + 1 < 8&& disk[x][y + 1] == other) {  //右
        i = p = x;
        j = q = y + 1;
        while(j < 8) {
            if(disk[i][j] == other) {j++; continue;}
            if(disk[i][j] == '-') break;
            if(disk[i][j] == chess) {
                while(q != j)
                    disk[p][q++] = chess;
                break;
            }
        }
    }
    if(x + 1 < 8&& y + 1 < 8&& disk[x + 1][y + 1] == other) {  //右下
        i = p = x + 1;
        j = q = y + 1;
        while(i < 8&& j < 8) {
            if(disk[i][j] == other) {i++; j++; continue;}
            if(disk[i][j] == '-') break;
            if(disk[i][j] == chess) {
                while(p != i&& q != j)
                    disk[p++][q++] = chess;
                break;
            }
        }
    }
    if(x + 1 < 8&& disk[x + 1][y] == other) {  //下
        i = p = x + 1;
        j = q = y;
        while(i < 8) {
            if(disk[i][j] == other) {i++; continue;}
            if(disk[i][j] == '-') break;
            if(disk[i][j] == chess) {
                while(p != i)
                    disk[p++][q] = chess;
                break;
            }
        }
    }
    if(x + 1 < 8&& y - 1 >= 0&& disk[x + 1][y - 1] == other) {  //左下
        i = p = x + 1;
        j = q = y - 1;
        while(i < 8&& j >= 0) {
            if(disk[i][j] == other) {i++; j--; continue;}
            if(disk[i][j] == '-') break;
            if(disk[i][j] == chess) {
                while(p != i&& q != j)
                    disk[p++][q--] = chess;
                break;
            }
        }
    }
    if(y - 1 >= 0&& disk[x][y - 1] == other) {  //左
        i = p = x;
        j = q = y - 1;
        while(j >= 0) {
            if(disk[i][j] == other) {j--; continue;}
            if(disk[i][j] == '-') break;
            if(disk[i][j] == chess) {
                while(q != j)
                    disk[p][q--] = chess;
                break;
            }
        }
    }
    int B = 0, W = 0;
    for(int i = 0; i < 8; i++)
        for(int j = 0; j < 8; j++)
            if(disk[i][j] == 'B') B++;
            else if(disk[i][j] == 'W') W++;
    printf("Black - %2d White - %2d\n", B, W);
}

void print_disk() {
    for(int i = 0; i < 8; i++)
        printf("%s\n", disk[i]);
    return ;
}

int main() {
//#ifndef ONLINE_JUDGE
//    freopen("my.in", "r", stdin);
//#endif // ONLINE_JUDGE
    int t, T = 0;
    scanf("%d", &t);
    getchar();
    while(t--) {
        T ? printf("\n") : T++;
        memset(disk, 0, sizeof(disk));
        for(int i = 0; i < 8; i++)
            gets(disk[i]);
        scanf("%c", &chess);
        getchar();
        while(1) {
            check();
            char cmd[MAXN];
            scanf("%s", cmd);
            getchar();
            if(cmd[0] == 'Q') break;
            if(cmd[0] == 'L') {
                bool ok = false;
                for(int i = 0; i < 8; i++) {
                    for(int j = 0; j < 8; j++) {
                        if(legal[i][j]) {
                            if(ok) printf(" ");
                            printf("(%d,%d)", i + 1, j + 1);
                            ok = true;
                        }
                    }
                }
                if(!ok) printf("No legal move.");
                printf("\n");
            }
            if(cmd[0] == 'M') {
                int x = cmd[1] - '0' - 1;
                int y = cmd[2] - '0' - 1;
                if(!check()) chess = other_chess();
                disk[x][y] = chess;
                change_chess(x, y);
                chess = other_chess();
            }
        }
        print_disk();
    }
    return 0;
}


xuziye0327
关注
专栏目录
UVA - 220 Othello
weixin_42547447的博客
11-29 716
传送门：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...
UVa 220 - Othello
_____
08-13 1788
一道黑白棋的模拟，难度上来说不算难，属于比较麻烦的……因为要八个方向去找去操作，没啥好说的，就是模拟。
UVA - 220 - Othello
weixin_30457551的博客
01-26 122
最害怕这种下棋的题了，情况特别多，考差细节特别多，当时没做，现在翻过头来再看一下，顺便复习一下基础。 这道题要注意格式，输出统计黑白棋子数的时候，数要占两位。其他都是普通的思路，顺着题目要求即可。 寒假刚刚开始，是提高自我的好时间，希望自己能利用起来。 #include <bits/stdc++.h> using namespace std; char tab[...
uva 220
qq_29904713的博客
07-19 205
uva 220 #include<bits/stdc++.h> using namespace std; string a[8],s; int T; char ch; int dist[8][2] = {{-1,0},{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1}}; int f[8]; int pan(int x,int y) {...
uva220 Othello
qq_41856690的博客
07-15 230
黑白棋题意就是模拟下棋，L：查询当前合法的下子位置，若无，特殊输出，若有，输出在一行。MXX：先判当前棋手是否有合法的下子位置，若无自动换人，然后下子，再换人（再换人这部分题目里没有说但是根据测试数据2可以推断出来）。        若有合法位置，下子，换人。        两种都要输出下子结束后双方棋的个数，注意格式为“Black - %2d White - %2d”。Q：结束当前棋局并打印棋盘...
Uva220 Othello
h1120023921的博客
08-04 1254
可用Udebug上的测试数据测试下（不全） 1.输出格式注意 程序结束的结尾换行是否有多  2.输出黑白棋子数的时候数字%2d输出 3.边界值注意 4.打印所有合法点的时候两点之间有空格 最有一个点输出没有空格 #include #include #include using namespace std; char board[8][8]={},current; int up(char current,int i,in
node-othello-lib:node-othello 的黑白棋游戏逻辑
05-30
《深入解析Node.js黑白棋游戏库：node-othello-lib》 在JavaScript的世界里，有许多优秀的库用于构建各种游戏，其中node-othello-lib是一个专为Node.js平台设计的黑白棋（也称翻转棋）游戏逻辑库。本文将详细探讨这...
Snake--Tetris--Othello.zip_othello_黑白Tetris
09-23
在本压缩包“Snake--Tetris--Othello.zip_othello_黑白Tetris”中，包含三个经典游戏的C语言实现：贪吃蛇（Snake）、俄罗斯方块（Tetris）以及黑白棋（Othello）。这些游戏不仅在计算机科学领域具有广泛的认识，而且...
projet-othello:Projet Appli ObjetPython-Jeu Othello
03-15
而复杂的AI可能涉及深度学习或搜索算法，如Minimax或Alpha-Beta剪枝，以模拟对手的可能行动，预测最优策略。 在实际开发中，开发者还需要考虑用户交互界面，这可能通过命令行实现，或者使用如Tkinter这样的图形库来...
Othello UVA - 220
qq_43185391的博客
02-02 257
题目链接： https://vjudge.net/problem/UVA-220 题目大意：你的任务是模拟黑白棋游戏的进程。黑白棋的规则：黑白双方轮流放棋子，每次必须让新放的棋子“夹住”至少一枚对方的棋子，然后把所有被新放的棋子“夹住”的对方棋子替换为己方棋子。一段连续（横，竖或者斜向）的同色棋子被“夹住”的条件是两端都是对方棋子（不能是空位）。注意：只有被新放的棋子夹住才会被替换。 输入：输入一...
UVa 220
JIBANCANYANG
01-31 849
背景：写了一天，调了一天多，题意太容易曲解了！！！花了很多时间，但是让我在实战中明白了很多。终于ac了！！ 学习：1.函数式的编程风格，是十分有益于调试的，也是十分有益于逻辑清晰的，在编程的时候注意逻辑清晰，结构明朗，往往会在调试阶段，省下很大的力。 3.棋盘类模拟题：代码简化方法就是用一个两行的二维数组来简化代码。int list[2][8]={1,0,0,1,-1,0,0,-1,1,1
UVa220
herhuel3200
02-17 564
/*** 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
UVa 220 （黑白棋）
weixin_30852367的博客
01-31 96
这道题也是个模拟，没什么特别的想法，提交时一定要小心空格、\n一定不要多，否则会WA 这就是我冗长的代码： //UVa 220 //Othello #define LOCAL #include <stdio.h> #include <string.h> //use memset strcmp char chess[10][10], cnt; v...
UVA - 220 Othello(模拟)
Chook_lxk的博客
01-28 264
点击打开题目链接 一秒钟想思路，一下午调BUG 注意的地方： 1.输出格式最后不要多加空行。 2.坐标之间一个空格间隔，行尾没空格 3.棋子数的输出%2d 4.No legal move.(我忘了点，udebug样例全过了,找了半天才找出来TAT) AC代码： #include #include #include using namespace std; int mp[10
UVA 220 黑白棋
xiaojiao_6的博客
07-07 600
这道题按照题目描述的三种指令来模拟即可。 Q–退出并打印当前棋盘，L–先明确当前是黑棋还是白旗的回合，然后搜索棋盘的每个位置看是否可以放，M–先检查当前回合是否有合法位置，如果没有切换双方回合然后放置，放置后修改棋盘和棋子数目。注意输出格式，特别是’Black - xx White - yy’，是%2d格式。代码如下：#include<cstdio> #include<iostream> #inc
uva 220 - Othello（黑白翻转棋）
SuCicada 小米的蝉
04-15 1432
习题4-3 黑白棋（Othello, ACM/ICPC World Finals 1992, UVa220） 你的任务是模拟黑白棋游戏的进程。黑白棋的规则为：黑白双方轮流放棋子，每次必须 让新放的棋子“夹住”至少一枚对方棋子，然后把所有被新放棋子“夹住”的对方棋子替换成己 方棋子。一段连续（横、竖或者斜向）的同色棋子被“夹住”的条件是两端都是对方棋子（不 能是空位）。如图4-
UVa220 黑白棋
u012861792的博客
08-23 442
题目不难，玩过黑白棋的都懂，关键是看清题目输入要求，还有坑爹的输出格式。 之前做过中国象棋的题目，已经有了基础了，所以做起来不难。然后象棋就已经搞了四个方向了，结果黑白棋直接来了8个方向，每个方向都要判断，最后出现了这个超长的代码。。。。。 #include&amp;lt;cstring&amp;gt; #include&amp;lt;cstdio&amp;gt; #include&amp;lt;iostream&amp;gt; using...
UVA220
02-20 115
这道题需要好好总结一下：因为虽然一开始我的思路是正确的，但是实现的方法却极其的复杂 先贴上我的代码 //之前的思路是没有问题的，但是在实现上缺乏一点灵活性，没有做到足够的抽象 //需求： //输入 //list当前棋方所有合法的位置（只要有一个方向合法就可以） //move，先判断这个位置+方向是不是合法，如果合法就更新棋盘 //如果想要判断和更新同时进行 //退出这...
BFS：UVa220 ACM/ICPC 1992-Othello（黑白棋）
二营长的意大利炮友
09-06 727
OthelloOthello 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. One player places disks with the white side up and the other player place
othello python
最新发布
12-11
Othello 是一种棋类游戏，也叫做翻转棋。这个游戏是由两人轮流下棋，在一个8x8的棋盘上，以黑白两色代表双方进行对战。游戏的目标是通过落子来翻转对方的棋子，并占领更多的棋盘格子。 Python 是一种高级编程语言，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值