UVa 220 - Othello（模拟）

最新推荐文章于 2019-07-19 19:18:30 发布
最新推荐文章于 2019-07-19 19:18:30 发布
阅读量598 收藏
点赞数
分类专栏： UVa 算法竞赛入门经典（第二版）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuziye0327/article/details/44207387
版权
本文分享了一个程序员在调试代码时遇到的意外错误——仅仅是因为多了一个空行导致程序无法正常运行。通过深入分析代码流程，作者最终发现了问题所在并解决了这一看似简单的bug。此案例提醒我们，在调试过程中要保持耐心和细致，有时候一些看似无关紧要的因素可能正是问题的关键。
摘要由CSDN通过智能技术生成

一道纯模拟题， 曾经写了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;
}


UVA - 220 Othello
weixin_42547447的博客
11-29 745
传送门：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 1801
一道黑白棋的模拟，难度上来说不算难，属于比较麻烦的……因为要八个方向去找去操作，没啥好说的，就是模拟。
UVA - 220 - Othello
weixin_30457551的博客
01-26 131
最害怕这种下棋的题了，情况特别多，考差细节特别多，当时没做，现在翻过头来再看一下，顺便复习一下基础。 这道题要注意格式，输出统计黑白棋子数的时候，数要占两位。其他都是普通的思路，顺着题目要求即可。 寒假刚刚开始，是提高自我的好时间，希望自己能利用起来。 #include <bits/stdc++.h> using namespace std; char tab[...
uva 220
qq_29904713的博客
07-19 216
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 238
黑白棋题意就是模拟下棋，L：查询当前合法的下子位置，若无，特殊输出，若有，输出在一行。MXX：先判当前棋手是否有合法的下子位置，若无自动换人，然后下子，再换人（再换人这部分题目里没有说但是根据测试数据2可以推断出来）。        若有合法位置，下子，换人。        两种都要输出下子结束后双方棋的个数，注意格式为“Black - %2d White - %2d”。Q：结束当前棋局并打印棋盘...
Uva220 Othello
h1120023921的博客
08-04 1272
可用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 270
题目链接： https://vjudge.net/problem/UVA-220 题目大意：你的任务是模拟黑白棋游戏的进程。黑白棋的规则：黑白双方轮流放棋子，每次必须让新放的棋子“夹住”至少一枚对方的棋子，然后把所有被新放的棋子“夹住”的对方棋子替换为己方棋子。一段连续（横，竖或者斜向）的同色棋子被“夹住”的条件是两端都是对方棋子（不能是空位）。注意：只有被新放的棋子夹住才会被替换。 输入：输入一...
UVa 220
JIBANCANYANG
01-31 862
背景：写了一天，调了一天多，题意太容易曲解了！！！花了很多时间，但是让我在实战中明白了很多。终于ac了！！ 学习：1.函数式的编程风格，是十分有益于调试的，也是十分有益于逻辑清晰的，在编程的时候注意逻辑清晰，结构明朗，往往会在调试阶段，省下很大的力。 3.棋盘类模拟题：代码简化方法就是用一个两行的二维数组来简化代码。int list[2][8]={1,0,0,1,-1,0,0,-1,1,1
UVa220
herhuel3200
02-17 574
/*** 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 103
这道题也是个模拟，没什么特别的想法，提交时一定要小心空格、\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 271
点击打开题目链接 一秒钟想思路，一下午调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 607
这道题按照题目描述的三种指令来模拟即可。 Q–退出并打印当前棋盘，L–先明确当前是黑棋还是白旗的回合，然后搜索棋盘的每个位置看是否可以放，M–先检查当前回合是否有合法位置，如果没有切换双方回合然后放置，放置后修改棋盘和棋子数目。注意输出格式，特别是’Black - xx White - yy’，是%2d格式。代码如下：#include<cstdio> #include<iostream> #inc
uva 220 - Othello（黑白翻转棋）
SuCicada 小米的蝉
04-15 1452
习题4-3 黑白棋（Othello, ACM/ICPC World Finals 1992, UVa220） 你的任务是模拟黑白棋游戏的进程。黑白棋的规则为：黑白双方轮流放棋子，每次必须 让新放的棋子“夹住”至少一枚对方棋子，然后把所有被新放棋子“夹住”的对方棋子替换成己 方棋子。一段连续（横、竖或者斜向）的同色棋子被“夹住”的条件是两端都是对方棋子（不 能是空位）。如图4-
UVa220 黑白棋
u012861792的博客
08-23 451
题目不难，玩过黑白棋的都懂，关键是看清题目输入要求，还有坑爹的输出格式。 之前做过中国象棋的题目，已经有了基础了，所以做起来不难。然后象棋就已经搞了四个方向了，结果黑白棋直接来了8个方向，每个方向都要判断，最后出现了这个超长的代码。。。。。 #include&amp;lt;cstring&amp;gt; #include&amp;lt;cstdio&amp;gt; #include&amp;lt;iostream&amp;gt; using...
UVA220
02-20 123
这道题需要好好总结一下：因为虽然一开始我的思路是正确的，但是实现的方法却极其的复杂 先贴上我的代码 //之前的思路是没有问题的，但是在实现上缺乏一点灵活性，没有做到足够的抽象 //需求： //输入 //list当前棋方所有合法的位置（只要有一个方向合法就可以） //move，先判断这个位置+方向是不是合法，如果合法就更新棋盘 //如果想要判断和更新同时进行 //退出这...
BFS：UVa220 ACM/ICPC 1992-Othello（黑白棋）
二营长的意大利炮友
09-06 739
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游戏智能代理：Minimax与Alpha-Beta剪枝
资源摘要信息:&quot;othello-agent&quot; 1. Othello游戏简介： Othello游戏，又称黑白棋或Reversi，是一种两人对弈的策略棋类游戏。它起源于十九世纪的英国，由“奥赛罗”演变而来。游戏的目标是使棋盘上自己的棋子数量多于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值