SDUTOJ3754_黑白棋(纯模拟)

于 2019-01-08 22:13:00 发布
阅读量919 收藏
点赞数
原文链接：http://www.cnblogs.com/iQXQZX/p/10258736.html
版权

黑白棋

Time Limit: 1000 ms Memory Limit: 65536 KiB

Submit Statistic

Problem Description

黑白棋是一种喜闻乐见的益智游戏，今天，我们就来玩一下。

黑白棋的棋盘由 8×8 的方格组成。棋子为黑色（黑方的棋子）或白色（白方的棋子），下棋时棋子放置在方格内。

每轮游戏的规则是，双方交替下棋，将自己颜色的棋子放在棋盘的空格上，而当自己放下的棋子在横、竖、斜 8 个方向内有一个自己的棋子，则被夹在中间的所有连续的对方棋子全部会翻转成为自己颜色的棋子（可以横着夹，竖着夹，或是斜着夹，被夹住的位置必须全部是对手的棋子，且中间不能有空格），允许同时在多个方向上翻转。

只有当在一个位置落下一个棋子，并且能翻转对手一个或多个棋子时，这个位置才是一个有效的下棋位置。当轮到某人时，可能存在一个或多个有效的下棋位置，也可能不存在有效的下棋位置。

 

例如：当前轮到黑方下棋，他的有效下棋位置在图中以凹陷效果标出。

3754

 

选择 4-C 位置下棋，则中间被夹住的白棋全部翻转为黑棋：

3754-2

 

现在给你一个当前棋局的盘面，并且给出这一轮下棋的人的执子颜色以及他想要下棋的位置，请你判断一下他的下棋位置是否是有效位置，如果是，则输出下棋之后的盘面。

Input

输入数据有多组（数据组数不超过 50），到 EOF 结束。

对于每组数据：

  • 第一行输入一个字符串，为 "BLACK" 或 "WHITE"，表示现在轮到哪一方下棋。
  • 接下来输入 8 行字符串，每行字符串包含 8 个字符，表示当前盘面。其中 '.' 表示空白位置，'B' 表示黑棋，'W' 表示白棋。
  • 最后一行输入用空格隔开的两个整数 a, b，表示棋手想要下棋的位置（第 a 行 第 b 列）。

Output

对于每组数据，如果当前棋手的下棋位置有效，则输出下棋之后的盘面和黑白棋手各自的得分，否则只输出一行 “invalid”（不包含引号）。

Sample Input

BLACK
........
........
........
...WB...
...BW...
........
........
........
4 3
WHITE
........
........
....W...
..BBBB..
...WBB..
..W.....
........
........
5 7

Sample Output

........
........
..BBB...
...BW...
........
........
........
4:1
........
........
....W...
..BBBW..
...WWWW.
..W.....
........
........
3:7

Hint

对于第一组示例，对应题目描述中的图片。

对于第二组示例，白方下棋位置在 (5, 7)，是一个有效位置。以 (5, 7) 为中心的 8 个方向中，向左可以和 (5, 4) 处的白棋一起夹住并翻转 2 个黑棋，向左上可以和 (3, 5) 处的白棋一起夹住翻转 1 个黑棋。

Source

【2016级《程序设计基础(B)I》期末上机考试-第一场】bLue

废了很大的力气才写出来  存一下留念吧  哈哈哈 300行

#include <bits/stdc++.h>
using namespace std;
char s1[10];
char s[10][10];
int main()
{

    int n, m;
    while (~scanf("%s", s1))
    {
        int flag = 0;
        for (int i = 1; i <= 8; i++)
        {
            for (int j = 1; j <= 8; j++)
                cin >> s[i][j];
        }
        if (strcmp(s1, "BLACK") == 0)
        {
            cin >> n >> m;
            s[n][m] = 'B';

            for (int i = m + 1; i <= 8; i++) // 找右
            {
                if (s[n][i] == '.')
                    break;
                if (s[n][i] == 'W')
                    continue;
                if (s[n][i] == 'B')
                {
                    for (int j = i - 1; j >= m + 1; j--)
                    {
                        s[n][j] = 'B';
                        flag = 1;
                    }

                    break;
                }
            }
            for (int i = m - 1; i >= 0; i--) // 左
            {
                if (s[n][i] == '.')
                    break;
                if (s[n][i] == 'W')
                    continue;
                if (s[n][i] == 'B')
                {
                    for (int j = i + 1; j <= m - 1; j++)
                    {
                        s[n][j] = 'B';
                        flag = 1;
                    }
                    break;
                }
            }
            for (int i = 1; n + i <= 8; i++) // 找下
            {
                if (s[n + i][m] == '.')
                    break;
                if (s[n + i][m] == 'W')
                    continue;
                if (s[n + i][m] == 'B')
                {
                    for (int j = 1; j <= i - 1; j++)
                    {
                        s[n + j][m] = 'B';
                        flag = 1;
                    }

                    break;
                }
            }
            for (int i = 1; n - i >= 0; i++) // 上
            {
                if (s[n - i][m] == '.')
                    break;
                if (s[n - i][m] == 'W')
                    continue;
                if (s[n - i][m] == 'B')
                {
                    for (int j = 1; j <= i - 1; j++)
                    {
                        s[n - j][m] = 'B';
                        flag = 1;
                    }
                    break;
                }
            }
            for (int i = 1; n - i >= 0 && m + i <= 8; i++) // 右上
            {
                if (s[n - i][m + i] == '.')
                    break;
                if (s[n - i][m + i] == 'W')
                    continue;
                if (s[n - i][m + i] == 'B')
                {
                    for (int j = 1; j <= i - 1; j++)
                    {
                        s[n - j][m + j] = 'B';
                        flag = 1;
                    }
                    break;
                }
            }
            for (int i = 1; n + i <= 8 && m - i >= 0; i++) // 左下
            {
                if (s[n + i][m - i] == '.')
                    break;
                if (s[n + i][m - i] == 'W')
                    continue;
                if (s[n + i][m - i] == 'B')
                {
                    for (int j = 1; j <= i - 1; j++)
                    {
                        s[n + j][m - j] = 'B';
                        flag = 1;
                    }
                    break;
                }
            }
            for (int i = 1; n - i >= 0 && m - i >= 0; i++) // 左上
            {
                if (s[n - i][m - i] == '.')
                    break;
                if (s[n - i][m - i] == 'W')
                    continue;
                if (s[n - i][m - i] == 'B')
                {
                    for (int j = 1; j <= i - 1; j++)
                    {
                        s[n - j][m - j] = 'B';
                        flag = 1;
                    }
                    break;
                }
            }
            for (int i = 1; n + i <= 8 && m + i <= 8; i++) // 右下
            {
                if (s[n + i][m + i] == '.')
                    break;
                if (s[n + i][m + i] == 'W')
                    continue;
                if (s[n + i][m + i] == 'B')
                {
                    for (int j = 1; j <= i - 1; j++)
                    {
                        s[n + j][m + j] = 'B';
                        flag = 1;
                    }
                    break;
                }
            }
        }
        if (strcmp(s1, "WHITE") == 0)
        {
            cin >> n >> m;
            s[n][m] = 'W';
            for (int i = m + 1; i <= 8; i++) // 找右
            {
                if (s[n][i] == '.')
                    break;
                if (s[n][i] == 'B')
                    continue;
                if (s[n][i] == 'W')
                {
                    for (int j = i - 1; j >= m + 1; j--)
                    {
                        s[n][j] = 'W';
                        flag = 1;
                    }
                    break;
                }
            }
            for (int i = m - 1; i >= 0; i--) // 左
            {
                if (s[n][i] == '.')
                    break;
                if (s[n][i] == 'B')
                    continue;
                if (s[n][i] == 'W')
                {
                    for (int j = i + 1; j <= m - 1; j++)
                    {
                        s[n][j] = 'W';
                        flag = 1;
                    }
                    break;
                }
            }
            for (int i = 1; n + i <= 8; i++) // 找下
            {
                if (s[n + i][m] == '.')
                    break;
                if (s[n + i][m] == 'B')
                    continue;
                if (s[n + i][m] == 'W')
                {
                    for (int j = 1; j <= i - 1; j++)
                    {
                        s[n + j][m] = 'W';
                        flag = 1;
                    }

                    break;
                }
            }
            for (int i = 1; n - i >= 0; i++) // 上
            {
                if (s[n - i][m] == '.')
                    break;
                if (s[n - i][m] == 'B')
                    continue;
                if (s[n - i][m] == 'W')
                {
                    for (int j = 1; j <= i - 1; j++)
                    {
                        s[n - j][m] = 'W';
                        flag = 1;
                    }
                    break;
                }
            }
            for (int i = 1; n - i >= 0 && m + i <= 8; i++) // 右上
            {
                if (s[n - i][m + i] == '.')
                    break;
                if (s[n - i][m + i] == 'B')
                    continue;
                if (s[n - i][m + i] == 'W')
                {
                    for (int j = 1; j <= i - 1; j++)
                    {
                        s[n - j][m + j] = 'W';
                        flag = 1;
                    }
                    break;
                }
            }
            for (int i = 1; n + i <= 8 && m - i >= 0; i++) // 左下
            {
                if (s[n + i][m - i] == '.')
                    break;
                if (s[n + i][m - i] == 'B')
                    continue;
                if (s[n + i][m - i] == 'W')
                {
                    for (int j = 1; j <= i - 1; j++)
                    {
                        s[n + j][m - j] = 'W';
                        flag = 1;
                    }
                    break;
                }
            }
            for (int i = 1; n - i >= 0 && m - i >= 0; i++) // 左上
            {
                if (s[n - i][m - i] == '.')
                    break;
                if (s[n - i][m - i] == 'B')
                    continue;
                if (s[n - i][m - i] == 'W')
                {
                    for (int j = 1; j <= i - 1; j++)
                    {
                        s[n - j][m - j] = 'W';
                        flag = 1;
                    }
                    break;
                }
            }
            for (int i = 1; n + i <= 8 && m + i <= 8; i++) // 右下
            {
                if (s[n + i][m + i] == '.')
                    break;
                if (s[n + i][m + i] == 'B')
                    continue;
                if (s[n + i][m + i] == 'W')
                {
                    for (int j = 1; j <= i - 1; j++)
                    {
                        s[n + j][m + j] = 'W';
                        flag = 1;
                    }
                    break;
                }
            }
        }

        if (!flag)
            cout << "invalid" << endl;
        else
        {
            for (int i = 1; i <= 8; i++)
            {
                for (int j = 1; j <= 8; j++)
                    printf("%c", s[i][j]);
                cout << endl;
            }
            int w = 0, b = 0;
            for (int i = 1; i <= 8; i++)
            {
                for (int j = 1; j <= 8; j++)
                {
                    if (s[i][j] == 'B')
                        b++;
                    else if (s[i][j] == 'W')
                        w++;
                }
            }
            cout << b << ":" << w << endl;
        }
    }
    return 0;
}

/***************************************************
User name: jk180602
Result: Accepted
Take time: 0ms
Take Memory: 156KB
Submit time: 2019-01-04 22:40:10
****************************************************/

 

转载于:https://www.cnblogs.com/iQXQZX/p/10258736.html

weixin_30856965
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
题目: 黑白棋游戏
ResCells的博客
08-08 970
题目：黑白棋游戏
黑白棋游戏 （BFS + 位运算初步运用）
一个蒟蒻！
08-13 1459
关于棋盘状态的存储，我们考虑将每个棋盘保存为一个二维数组，在判定新节点的时候需要将新产生的棋盘与前面已有的棋盘逐个比对，但空间和时间消耗都比较大。 标记数组（标记状态是否出现过）的基础类型是bool，每个单元要用一个字节存储，而里面只存储了0和1，实际上浪费了很多空间，有没有办法可以进一步优化呢？.........
黑白棋
sdut16szq的博客
01-07 1152
黑白棋Problem Description黑白棋是一种喜闻乐见的益智游戏，今天，我们就来玩一下。 黑白棋的棋盘由 8×8 的方格组成。棋子为黑色（黑方的棋子）或白色（白方的棋子），下棋时棋子放置在方格内。 每轮游戏的规则是，双方交替下棋，将自己颜色的棋子放在棋盘的空格上，而当自己放下的棋子在横、竖、斜 8 个方向内有一个自己的棋子，则被夹在中间的所有连续的对方棋子全部会翻转成为自己颜色的棋子（
[NOIP模拟赛]黑白棋
UISG103的博客
08-26 649
题目描述 给你一个n*n的网格。每个格子只会是这三种之一：x(黑块),o(白块),.(空格)。当前网格上没有任意两个白块相邻，任意白块上下左右必有一个空格。 现在你要向空格上放黑块，对于任意一个白块上下左右如果全是黑块，那么这个白块就会变成空格。求空格最大能达到多少个？ 输入格式 第1行：1个整数n（n ≤ 50），表示网格的大小接下来n行，每行n个字符，描述网格 输出格式 第1行：1
WUST OJ 2055: 黑白棋
Mitsuha_的博客
08-01 641
WUST OJ 2055: 黑白棋 围棋的棋子分为白棋和黑棋，你最开始什么都没有。你可以一次得到两颗黑棋或者用一颗黑棋换取换一颗白棋。若干次后，你发现自己拥有m颗黑棋和n颗白棋，请问有多少种可能的方法使你获得了这些棋子。获得顺序不同认为是不同方法。
wbc.rar_othello_黑白棋_黑白棋 搜索
09-20
标题中的“wbc.rar_othello_黑白棋_黑白棋 搜索”暗示这是一个关于Othello游戏（也称为黑白棋）的压缩包文件，其中可能包含实现这个游戏的源代码或相关资源。描述部分提到，作者在大学时期编写了这个黑白棋程序，...
黑白棋子的算法程序实现.rar_黑白棋_黑白棋 算法
09-21
黑白棋，又称翻转棋或反棋，是一种极具策略性的双人对弈游戏。在编程领域，实现黑白棋的算法程序是一项有趣的挑战，涉及到搜索算法、博弈论和数据结构等多方面知识。以下是对这个程序实现的详细解析： 1. **游戏...
VC++黑白棋.rar_黑白棋 VC++
07-15
【标题】"VC++黑白棋.rar_黑白棋 VC++" 是一个使用Microsoft Visual C++（简称VC++）编写的黑白棋游戏源代码包。这个项目旨在帮助编程初学者理解和学习如何利用C++语言来实现一个桌面游戏。黑白棋，又称为翻转棋，是...
黑白棋剪枝版_黑白棋_
10-01
黑白棋，又称翻转棋或反棋，是一种深受玩家喜爱的双人策略棋类游戏。在这款游戏中，玩家可以选择黑棋或白棋进行对弈，目标是通过巧妙的布局使得自己颜色的棋子占据棋盘的多数。当一方的棋子完全填满棋盘时，该方即为...
black&white.rar_white _黑白棋
09-23
黑白棋，又称翻转棋（Reversi）或奥赛罗棋（Othello），是一种双人对弈的策略棋类游戏。在这个“black&white.rar_white _黑白棋”压缩包中，我们可以找到一个由VC++（Visual C++）开发的黑白棋游戏程序。VC++是微软...
黑白棋的人工智能（10秒钟思考8-12层）
06-18
黑白棋的思考程序（字符界面） 10秒种可以思考8-12层深度 板砖请轻拍……
黑白棋(带简单AI)
12-15
自己写的黑白棋，有简单的AI,可以双人对战或人机对战。有悔棋功能。有计时功能。
简易黑白棋
08-28
一个魔方的简易模拟, 主要是设计数据结构相关的知识, swing 等等
习题4-3　黑白棋（Othello, ACM/ICPC World Finals 1992, UVa220）
weixin_42193704的博客
08-15 670
代码转载自：https://blog.csdn.net/XieNaoban/article/details/52078533 你的任务是模拟黑白棋游戏的进程。黑白棋的规则为：黑白双方轮流放棋子，每次必须 让新放的棋子“夹住”至少一枚对方棋子，然后把所有被新放棋子“夹住”的对方棋子替换成己 方棋子。一段连续（横、竖或者斜向）的同色棋子被“夹住”的条件是两端都是对方棋子（不 能是空位）。如图4-6（...
（模拟）uva 220 黑白棋
Lighting_的博客
01-24 717
#include #include #include using namespace std; int board[10][10],xx,yy,queue[9],rear; //player 1 and 2; void print_b() { for(int i=1;i<=8;i++) { for(int m=1;m<=8;m++) printf("%c",board[i][m]?
ACM篇：UVA220黑白棋总结
Ace_is_my_name的博客
11-01 1040
大概算入门了？反复折腾四小时，还是太嫩了。很纯粹的模拟。需要注意的是输出格式，比如最后一个（i，j）后没有空格，最后一场棋后也无回车，以及输出棋子数量时数字占两位。简单思路。LIST：遍历棋盘，每个点单独判断八个方向是否有同色棋子，有即返回。MOVE：放下棋子，依次修改。相比判断同色棋子的过程，它只多了修改操作，因此我采用的是同一个函数，以bool关键字区别。QUIT：打印。第一次写博客，希望感兴
翻转棋
u012584987的专栏
11-28 6104
广搜的问题，重点是位运算的应用。每翻转一个状态就对应一个16位的二进制数。翻转一次就是把某个数上下左右四个位置的棋子都翻转，即0->1,1->0。 Flip Game Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 26891   Accepted: 11647
sdut-黑白棋游戏
最新发布
06-25
SDUT-黑白棋游戏，可能是指某款特定的编程或算法练习项目，SDUT（Software Development University of Tsinghua）通常指的是清华大学软件学院。黑白棋，又称五子棋，是一种双人对弈的策略棋类游戏，棋盘为15x15或19...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值