220 Othello

最新推荐文章于 2019-06-16 22:09:00 发布
最新推荐文章于 2019-06-16 22:09:00 发布
阅读量562 收藏
点赞数
分类专栏： 模拟
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013451221/article/details/37994669
版权

搜索题，一步一步模拟就行。。。不知道我方法有问题还是什么的，敲了500行，过了。。

注意一下 格式的控制

一开始想 的是 走步 算一个函数，判断是否可走是一个函数

之后发现太麻烦了，走路和判断放在一起

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<map>
#include<vector>
#include<stack>
#include<queue>
#include<set>
#include<list>
#include<cmath>
using namespace std;
typedef long long LL;
#define ALL(x) x.begin(),x.end()
char Map[10][10];
int  turn;
bool solve(int x,int y,int t){
    /*8个方向*/
    /*上*/
    int pos ;
    int ans = 0;
    int ok = 0;
    for(int i = x - 1; i >= 0 ; i --){
        if(turn == 0) /*黑子走的话*/{
            if(Map[i][y] == 'B'){
                ok = 1;
                pos = i;
                break;
            }
        }
        else if(turn == 1)/*白子走的话*/{
            if(Map[i][y] == 'W'){
                ok = 1;
                pos = i;
                break;
            }
        }
    }
    if(ok && turn == 0){  /*黑色先走的话*/
        int have_white = 0;
        int is_ok = 1;
        for(int i = pos + 1 ; i < x ; i++){
            if(Map[i][y] == 'W') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1) /*如果需要修改*/{
            for(int j = pos + 1; j < x ; j++) Map[j][y] = 'B';
        }
            ans = 1;
        }
    }
    else if(ok && turn == 1){  /*白色先走的话*/
        int have_white = 0;
        int is_ok = 1;
        for(int i = pos + 1 ; i < x ; i++){
            if(Map[i][y] == 'B') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int j = pos + 1; j < x ; j ++) Map[j][y] = 'W';
            ans = 1;
        }
    }
    /*======================================*/
    /*下*/
    ok = 0;
    for(int i = x + 1; i < 8 ; i ++){
        if(turn == 0) /*黑子走的话*/{
            if(Map[i][y] == 'B'){
                ok = 1;
                pos = i;
                break;
            }
        }
        else if(turn == 1)/*白子走的话*/{
            if(Map[i][y] == 'W'){
                ok = 1;
                pos = i;
                break;
            }
        }
    }
    if(ok && turn == 0){  /*黑色先走的话*/
        int have_white = 0;
        int is_ok = 1;
        for(int i = pos - 1 ; i > x ; i--){
            if(Map[i][y] == 'W') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int j = pos - 1; j > x ; j --) Map[j][y] = 'B';
            ans = 1;
        }
    }
    else if(ok && turn == 1){  /*白色先走的话*/
        int have_white = 0;
        int is_ok = 1;
        for(int i = pos - 1 ; i > x ; i--){
            if(Map[i][y] == 'B') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int j = pos - 1; j > x ; j --) Map[j][y] = 'W';
            ans = 1;
        }
    }
    /*==============================================*/
    /*左*/
    ok = 0;
    for(int i = y - 1; i >= 0; i --){
        if(turn == 0) /*黑子走的话*/{
            if(Map[x][i] == 'B'){
                ok = 1;
                pos = i;
                break;
            }
        }
        else if(turn == 1)/*白子走的话*/{
            if(Map[x][i] == 'W'){
                ok = 1;
                pos = i;
                break;
            }
        }
    }
    if(ok && turn == 0){  /*黑色先走的话*/
        int have_white = 0;
        int is_ok = 1;
        for(int i = pos + 1 ; i < y ; i ++){
            if(Map[x][i] == 'W') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int j = pos + 1; j < y ; j ++) Map[x][j] = 'B';
            ans = 1;
        }
    }
    else if(ok && turn == 1){  /*白色先走的话*/
        int have_white = 0;
        int is_ok = 1;
        for(int i = pos + 1 ; i < y ; i ++){
            if(Map[x][i] == 'B') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int j = pos + 1; j < y ; j ++) Map[x][j] = 'W';
            ans = 1;
        }
    }
    /*=================================================*/
    /*右*/
    ok = 0;
    for(int i = y + 1; i < 8; i ++){
        if(turn == 0) /*黑子走的话*/{
            if(Map[x][i] == 'B'){
                ok = 1;
                pos = i;
                break;
            }
        }
        else if(turn == 1)/*白子走的话*/{
            if(Map[x][i] == 'W'){
                ok = 1;
                pos = i;
                break;
            }
        }
    }
    if(ok && turn == 0){  /*黑色先走的话*/
        int have_white = 0;
        int is_ok = 1;
        for(int i = pos - 1 ; i > y ; i --){
            if(Map[x][i] == 'W') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int j = pos - 1; j > y ; j --) Map[x][j] = 'B';
            ans = 1;
        }
    }
    else if(ok && turn == 1){  /*白色先走的话*/
        int have_white = 0;
        int is_ok = 1;
        for(int i = pos - 1 ; i > y ; i --){
            if(Map[x][i] == 'B') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int j = pos - 1; j > y ; j --) Map[x][j] = 'W';
            ans = 1;
        }
    }
    /*=================================*/
    /*左上*/
    int pos_x,pos_y;
    ok = 0;
    for(int i = x - 1, j = y - 1; i >= 0 &&  j >= 0; i --, j --){
        if(turn == 0) /*黑子走的话*/{
            if(Map[i][j] == 'B'){
                ok = 1;
                pos_x = i;
                pos_y = j;
                break;
            }
        }
        else if(turn == 1)/*白子走的话*/{
            if(Map[i][j] == 'W'){
                ok = 1;
                pos_x = i;
                pos_y = j;
                break;
            }
        }
    }
    if(ok && turn == 0){  /*黑色先走的话*/
        int have_white = 0;
        int is_ok = 1;
        for(int i = pos_x + 1 , j = pos_y + 1; i < x && j < y ; i ++ , j++){
            if(Map[i][j] == 'W') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int a = pos_x + 1 , b = pos_y + 1; a < x && b < y ; a ++ , b++)
        Map[a][b] = 'B';
            ans = 1;
        }
    }
    else if(ok && turn == 1){  /*白色先走的话*/
        int have_white = 0;
        int is_ok = 1;
        for(int i = pos_x + 1 , j = pos_y + 1; i < x && j < y ; i ++ , j ++){
            if(Map[i][j] == 'B') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int a = pos_x + 1 , b = pos_y + 1; a < x && b < y ; a ++ , b++)
        Map[a][b] = 'W';
            ans = 1;
        }
    }
    /*========================================*/
    /*右下*/
    ok = 0;
    for(int i = x + 1, j = y + 1; i < 8 &&  j < 8; i ++, j ++){
        if(turn == 0) /*黑子走的话*/{
            if(Map[i][j] == 'B'){
                ok = 1;
                pos_x = i;
                pos_y = j;
                break;
            }
        }
        else if(turn == 1)/*白子走的话*/{
            if(Map[i][j] == 'W'){
                ok = 1;
                pos_x = i;
                pos_y = j;
                break;
            }
        }
    }
    if(ok && turn == 0){  /*黑色先走的话*/
        int have_white = 0;
        int is_ok = 1;
        for(int i = pos_x - 1 , j = pos_y - 1; i > x && j > y ; i -- , j--){
            if(Map[i][j] == 'W') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int a = pos_x - 1 , b = pos_y - 1; a > x && b > y ; a -- , b--)
        Map[a][b] = 'B';
            ans = 1;
        }
    }
    else  if(ok && turn == 1){  /*黑色先走的话*/
        int have_white = 0;
        int is_ok = 1;
        for(int i = pos_x - 1 , j = pos_y - 1; i > x && j > y ; i -- , j--){
            if(Map[i][j] == 'B') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int a = pos_x - 1 , b = pos_y - 1; a > x && b > y ; a -- , b--)
        Map[a][b] = 'W';
            ans = 1;
        }
    }
    /*=================================================*/
    /*右上*/
    ok = 0;
    for(int i = x - 1, j = y + 1; i >= 0 &&  j < 8; i --, j ++){
        if(turn == 0) /*黑子走的话*/{
            if(Map[i][j] == 'B'){
                ok = 1;
                pos_x = i;
                pos_y = j;
                break;
            }
        }
        else if(turn == 1)/*白子走的话*/{
            if(Map[i][j] == 'W'){
                ok = 1;
                pos_x = i;
                pos_y = j;
                break;
            }
        }
    }
    if(ok && turn == 0){  /*黑色先走的话*/
        int have_white = 0;
        int is_ok = 1;
        for(int i = pos_x + 1 , j = pos_y - 1; i < x && j > y ; i ++ , j--){
            if(Map[i][j] == 'W') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int a = pos_x + 1 , b = pos_y - 1; a < x && b > y ; a ++ , b--)
        Map[a][b] = 'B';
            ans = 1;
        }
    }
    else  if(ok && turn == 1){  /*黑色先走的话*/
       int have_white = 0;
        int is_ok = 1;
        for(int i = pos_x + 1 , j = pos_y - 1; i < x && j > y ; i ++ , j--){
            if(Map[i][j] == 'B') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int a = pos_x + 1 , b = pos_y - 1; a < x && b > y ; a ++ , b--)
        Map[a][b] = 'W';
            ans = 1;
        }
    }
    /*=================================左下*/
        ok = 0;
    for(int i = x + 1, j = y - 1; i < 8 &&  j >= 0; i ++, j --){
        if(turn == 0) /*黑子走的话*/{
            if(Map[i][j] == 'B'){
                ok = 1;
                pos_x = i;
                pos_y = j;
                break;
            }
        }
        else if(turn == 1)/*白子走的话*/{
            if(Map[i][j] == 'W'){
                ok = 1;
                pos_x = i;
                pos_y = j;
                break;
            }
        }
    }
    if(ok && turn == 0){  /*黑色先走的话*/
        int have_white = 0;
        int is_ok = 1;
        for(int i = pos_x - 1 , j = pos_y + 1; i > x && j < y ; i -- , j++){
            if(Map[i][j] == 'W') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int a = pos_x - 1 , b = pos_y + 1; a > x && b < y ; a -- , b ++)
        Map[a][b] = 'B';
            ans = 1;
        }
    }
    else  if(ok && turn == 1){  /*黑色先走的话*/
       int have_white = 0;
        int is_ok = 1;
        for(int i = pos_x - 1 , j = pos_y + 1; i > x && j < y ; i -- , j++){
            if(Map[i][j] == 'B') have_white = 1;
            else {
                is_ok = 0;
                break;
            }
        }
        if(is_ok && have_white) {
        if(t == 1)
        for(int a = pos_x - 1 , b = pos_y + 1; a > x && b < y ; a -- , b ++)
        Map[a][b] = 'W';
            ans = 1;
        }
    }
    if(ans == 0)
    return false;
    else {
        if(t == 1){
        if(turn == 0)
        Map[x][y] = 'B';
        else
        Map[x][y] = 'W';
        }
        return true;
    }
}
int count_black ;
int count_white ;
void Get_Number(){
    for(int i = 0 ; i < 8 ; i ++)
      for(int j = 0 ; j < 8 ; j ++)
        if(Map[i][j] == 'W') count_white++;
        else
        if(Map[i][j] == 'B') count_black++;
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        for(int i = 0 ; i < 8 ; i++)
          scanf("%s",Map[i]);
        char str[10];
        while(scanf("%s",str)){
            if(str[0] == 'Q') {
            for(int i = 0 ; i < 8 ; i++)
            puts(Map[i]);
            break;
            }
            if(str[0] == 'W') turn = 1;      /*白色为1*/
       else if(str[0] == 'B') turn = 0; /*黑色为0*/
       else if(str[0] == 'L'){          /*遍历所有的点*/
                int ok = 0;
                for(int i = 0 ; i < 8 ; i++)
                   for(int j = 0 ; j < 8 ; j++)
                   if(Map[i][j] == '-' && solve(i,j,0)){
                   if(ok)
                   printf(" (%d,%d)",i + 1, j + 1);
                   else{
                   printf("(%d,%d)",i + 1, j + 1);
                   ok = 1;
                   }
                }
                if(!ok) printf("No legal move.");
                printf("\n");
            }
            else if(str[0] == 'M'){
                int x = str[1] - '0';
                int y = str[2] - '0';
                int t = solve(x - 1,y - 1,1);
                if(t){
                    count_black = 0;
                    count_white = 0;
                    Get_Number();
                }
                else {
                    if(turn == 1) turn = 0;
                    else if(turn == 0) turn = 1;
                    solve(x - 1,y - 1,1);
                    count_black = 0;
                    count_white = 0;
                    Get_Number();
                }
                printf("Black -%3d White -%3d\n",count_black,count_white);
                if(turn == 1) turn = 0;
                else if(turn == 0) turn = 1;
            }
        }
        if(T > 0) printf("\n");
    }
    return 0;
}


KinderRiven
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
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...
模拟退火求n个点到某点距离和最短
花月阁
05-06 4982
/* 找出一个点使得这个店到n个点的最长距离最短，即求最小覆盖圆的半径 用一个点往各个方向扩展，如果结果更优，则继续以当前步长扩展，否则缩小步长 */ #include #include #include const double pi = acos(-1.0); struct point { double x,y; }p[1010]; int n; point mid,tmid; dou
uva220 Othello
qq_41856690的博客
07-15 209
黑白棋题意就是模拟下棋，L：查询当前合法的下子位置，若无，特殊输出，若有，输出在一行。MXX：先判当前棋手是否有合法的下子位置，若无自动换人，然后下子，再换人（再换人这部分题目里没有说但是根据测试数据2可以推断出来）。        若有合法位置，下子，换人。        两种都要输出下子结束后双方棋的个数，注意格式为“Black - %2d White - %2d”。Q：结束当前棋局并打印棋盘...
UVA 220 Othello
weixin_30888707的博客
06-16 73
题目链接：https://vjudge.net/problem/UVA-220 题目翻译摘自《算法禁赛入门经典》 题目大意 　　你的任务是模拟黑白棋游戏的进程。 　　有 3 种指令： L指令：打印所有合法操作，按照从上到下，从左到右的顺序排列（没有合法操作时输出 No legal move）。 M指令：放一枚棋子在 (x, y)。如果当前游戏者没有合法操作，则是先切换游戏...
UVa 220 Othello
launch8的博客
06-03 241
这个题的思路也比较清晰，依然花了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
Uva220 Othello
weixin_30633405的博客
01-09 61
Othello 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. One player places disks with the white side up and t...
aa.rar_othello
09-14
黑白棋（Othello），又称翻转棋、反棋，是一款深受全球玩家喜爱的策略性棋类游戏。本篇将详细解析&quot;aa.rar_othello&quot;压缩包中提供的黑白棋源码，帮助读者深入理解其背后的逻辑和编程技巧。 首先，我们要明确源码的...
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以其轻量级、易...
BW.rar_othello_黑白棋
09-22
黑白棋，又叫反棋(Reversi)、奥赛罗棋(Othello)、苹果棋或翻转棋。黑白棋在西方和日本很流行。游戏通过相互翻转对方的棋子，最后以棋盘上谁的棋子多来判断胜负。 它的游戏规则简单，因此上手很容易，但是它的变化又...
bw.rar_bw源码_othello
09-21
【bw.rar_bw源码_othello】是一个包含黑白棋（也称为翻转棋或奥赛罗）游戏的源代码包。黑白棋是一种双人策略游戏，由日本的江户时代发展而来，全球范围内广受欢迎。这个源码包是模式识别系列搜索算法在游戏开发中的...
【UVA】230 - Borrowers（map模拟）
花月阁
08-21 2109
利用map判断一本书的状态，0代表借出去了，1代表在暑假，2代表换回来但是还未放回书架 设计一些字符串的处理问题，用一些字符串搜索函数比如 strstr , strchar等等 14072706 230 Borrowers Accepted C++ 0.015 2014-08-21 02:59:27 AC代码： #in
【uva】1600 - Patrol Robot
花月阁
07-23 1958
用一个vis[x][y][z]表示走到x，y的时候 穿过了zdu
uva-1592 Database[STL应用]
花月阁
07-19 1569
一道刘汝佳入门经典【第二版】的例题，不过书上没有标程，利用STL函数进行转换
【UVA】815 - Flooded!
花月阁
08-20 1315
水题，排序之后依次累加，模拟。 14069284 815 Flooded! Accepted C++ 0.032 2014-08-20 10:42:17 AC代码： #include #include #include #include #include #include #include #include #inclu
804 - Petri Net Simulation(简单魔模拟)
花月阁
05-19 1314
比较简单的,注意的问题是一个输入库可能话费多个货物进行转化,需要对输入进行特殊处理   Problem   Verdict Lang Time Best Rank Submit Time  | discuss804 - Petri Net Simulation  Accepted C++ 0.099 0.028 14
【hdu】The Donkey of Gui Zhou（搜索）
花月阁
09-16 1233
一开始的思路是，先走驴子，之后走老虎，每次走的时候记录他们的达到该位置的步数，如果一样就可以相遇，特殊处理末尾。 但是没办法过，之后索性让他们一起走，一起修改移动的坐标，结果过了。。。 真心不知道错哪了。。 11662502 2014-09-16 00:43:01 Accepted 4740 31MS 8300K 2547 B G++ KinderRiven
【SGU】271. Book Pile（双端队列模拟）
花月阁
03-31 1212
一摞书，2个操作，一个操作是在书堆上加一本，第二个将前K个书翻转 看别人用Splay树做的，但是可以用双端队列模拟，因为K个书之后的书位置已经定下来了，所以只需要记录在队列头加书还是尾加书 #include #include #include #include #include #include #include using namespace std; int main(){ int
【uva】225 - Golygons（dfs有坑）
花月阁
07-31 1162
dfs的路径问题，毕竟坑d
othello python
最新发布
12-11
Othello 是一种棋类游戏，也叫做翻转棋。这个游戏是由两人轮流下棋，在一个8x8的棋盘上，以黑白两色代表双方进行对战。游戏的目标是通过落子来翻转对方的棋子，并占领更多的棋盘格子。 Python 是一种高级编程语言，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值