象棋 UVa1589

最新推荐文章于 2024-07-28 10:44:26 发布
最新推荐文章于 2024-07-28 10:44:26 发布
阅读量810 收藏 1
点赞数 1
分类专栏： 算法 文章标签： uva 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yinaoxiong/article/details/66970399
版权

　　看到这个题目基本的想法是，将黑将能走的四个方向都遍历一遍，然后再判断判断红方能否吃掉它。如果所有可能的走向都会被将死，则黑将被将死。需要注意越界，吃子，和马被别脚的情况。附上一张自己画的一张简图可能会清楚一些：
　　思路导图
下面贴一下代码，更详细的解释在代码的注释里，代码有点冗长，有能力的可以把相同的地方写成函数（比如说帅和车的判断是可以放一起的）

#include<iostream>
#include<fstream>
using namespace std;
struct qizhi
{
    char kind;
    int row;
    int column;
};

int panduan(int b_row, int b_column, int size, const qizhi*  p)   //用来判断黑将走某一步会不会被将死,如果会死返回0，不会返回1
{
    for (int i = 0; i < size; ++i)
    {
        switch (p[i].kind)
        {
        case 'G':
            if (p[i].column == b_column)
            {
                int key = 0;   //标记，
                for (int j = 0; j < size; ++j)    //如果黑将和红帅在同列，判断中间有没有其他的旗子
                {
                    if (j == i)
                        continue;
                    if (p[j].column == p[i].column&&p[j].row > b_row&&p[j].row < p[i].row)
                    {
                        key = 1;
                        break;
                    }
                }
                if (0 == key)
                    return 0;            //如果key为0，表面被将死直接返回0
            }
            break;
        case 'R':
            if (p[i].column == b_column)
            {
                int key = 0, key1;   //标记，
                p[i].row > b_row ? key1 = 1 : key1 = 0;
                for (int j = 0; j < size; ++j)    //如果黑将和车在同列，判断中间有没有其他的旗子
                {
                    if (j == i)
                        continue;
                    if (key1 == 1)
                    {
                        if (p[j].column == p[i].column&&p[j].row > b_row&&p[j].row < p[i].row)
                        {
                            key = 1;
                            break;
                        }
                    }
                    else
                    {
                        if (p[j].column == p[i].column&&p[j].row <b_row&&p[j].row > p[i].row)
                        {
                            key = 1;
                            break;
                        }
                    }

                }
                if (0 == key)
                    return 0;            //如果key为0，表明被将死直接返回0
            }
            if (p[i].row == b_row)
            {
                int key = 0, key1;   //标记，
                p[i].column > b_column ? key1 = 1 : key1 = 0;
                for (int j = 0; j < size; ++j)    //如果黑将和车在同行，判断中间有没有其他的旗子
                {
                    if (j == i)
                        continue;
                    if (key1 == 1)
                    {
                        if (p[j].row == p[i].row&&p[j].column > b_column&&p[j].column < p[i].column)
                        {
                            key = 1;
                            break;
                        }
                    }
                    else
                    {
                        if (p[j].row == p[i].row&&p[j].column < b_column&&p[j].column > p[i].column)
                        {
                            key = 1;
                            break;
                        }
                    }

                }
                if (0 == key)
                    return 0;            //如果key为0，表明被将死直接返回0
            }
            break;
        case 'C':
            if (p[i].column == b_column)
            {
                int key = 0, key1;   //标记，
                p[i].row > b_row ? key1 = 1 : key1 = 0;
                for (int j = 0; j < size; ++j)    //如果黑将和炮在同列，判断中间有多少个旗子
                {
                    if (j == i)
                        continue;
                    if (1 == key1)
                    {
                        if (p[j].column == p[i].column&&p[j].row > b_row&&p[j].row < p[i].row)
                        {
                            key += 1;
                        }
                    }
                    else
                    {
                        if (p[j].column == p[i].column&&p[j].row<b_row&&p[j].row>p[i].row)
                        {
                            key += 1;
                        }
                    }

                }
                if (1 == key)
                    return 0;            //如果key为1，表明被将死直接返回0
            }
            if (p[i].row == b_row)
            {
                int key = 0, key1;   //标记，
                p[i].column > b_column ? key1 = 1 : key1 = 0;
                for (int j = 0; j < size; ++j)    //如果黑将和炮在同行，判断中间有多少个旗子
                {
                    if (j == i)
                        continue;
                    if (1 == key1)
                    {
                        if (p[j].row == p[i].row&&p[j].column > b_column&&p[j].column < p[i].column)
                        {
                            key += 1;
                        }
                    }
                    else
                    {
                        if (p[j].row == p[i].row&&p[j].column<b_column&&p[j].column>p[i].column)
                        {
                            key += 1;
                        }
                    }
                }
                if (1 == key)
                    return 0;            //如果key为1，表明被将死直接返回0
            }
            break;
         case 'H':
            int up = 0, down = 0, left = 0, right = 0;
            for (int j = 0; j < size; ++j)    //判断向上是否会别马脚
            {
                if (j == i)
                    continue;
                if (p[j].row == p[i].row - 1 && p[j].column == p[i].column)
                {
                    up = 1;
                    break;                          //如果别马脚，就结束
                }
            }
            if (0 == up)
            {
                if (p[i].column - 1 == b_column&&p[i].row - 2 == b_row)
                    return 0;
                else if (p[i].column + 1 == b_column&&p[i].row - 2 == b_row)
                    return 0;
            }
            for (int j = 0; j < size; ++j)    //判断向左是否会别马脚
            {
                if (j == i)
                    continue;
                if (p[j].row == p[i].row && p[j].column == p[i].column - 1)
                {
                    left = 1;
                    break;                          //如果别马脚，就结束
                }
            }
            if (0 == left)
            {
                if (p[i].column - 2 == b_column&&p[i].row - 1 == b_row)
                    return 0;
                else if (p[i].column - 2 == b_column&&p[i].row + 1 == b_row)
                    return 0;
            }
            for (int j = 0; j < size; ++j)    //判断向右是否会别马脚
            {
                if (j == i)
                    continue;
                if (p[j].row == p[i].row && p[j].column == p[i].column + 1)
                {
                    right = 1;
                    break;                          //如果别马脚，就结束
                }

            }
            if (0 == right)
            {
                if (p[i].column + 2 == b_column&&p[i].row - 1 == b_row)
                    return 0;
                else if (p[i].column + 2 == b_column&&p[i].row + 1 == b_row)
                    return 0;
            }
            for (int j = 0; j < size; ++j)    //判断向下是否会别马脚
            {
                if (j == i)
                    continue;
                if (p[j].row == p[i].row + 1 && p[j].column == p[i].column)
                {
                    down = 1;
                    break;                          //如果别马脚，就结束
                }

            }
            if (0 == down)
            {
                if (p[i].column - 1 == b_column&&p[i].row + 2 == b_row)
                    return 0;
                else if (p[i].column + 1 == b_column&&p[i].row + 2 == b_row)
                    return 0;
            }
            break;


        }
    }
    return 1;
}

int yes_or_no(int b_row, int b_column, int size, qizhi*  p)               //判断有没有被将死，将死返回false，没死返回true
{
    int up = 0, down = 0, left = 0, right = 0;
    if (b_row - 1 > 0)                         //判断向上走会不会死
    {
        for (int i = 0; i < size; ++i)
        {
            if (p[i].column == b_column&&p[i].row == b_row - 1)      //判断黑将去的地方有没有红棋的子如果有吃掉
            {
                p[i].kind = ' ';
                break;
            }
        }
        up = panduan(b_row - 1, b_column, size, p);
    }
    if (b_row + 1 < 4)                                   //判断向下走会不会死
    {
        for (int i = 0; i < size; ++i)
        {
            if (p[i].column == b_column&&p[i].row == b_row + 1)      //判断黑将去的地方有没有红棋的子如果有吃掉
            {
                p[i].kind = ' ';
                break;
            }
        }
        down = panduan(b_row + 1, b_column, size, p);
    }
    if (b_column - 1 > 3)                               //判断向左走会不会死
    {
        for (int i = 0; i < size; ++i)
        {
            if (p[i].column == b_column - 1 && p[i].row == b_row)      //判断黑将去的地方有没有红棋的子如果有吃掉
            {
                p[i].kind = ' ';
                break;
            }
        }
        left = panduan(b_row, b_column - 1, size, p);
    }
    if (b_column + 1 < 7)                       //判断向右走会不会死
    {
        for (int i = 0; i < size; ++i)
        {
            if (p[i].column == b_column + 1 && p[i].row == b_row)      //判断黑将去的地方有没有红棋的子如果有吃掉
            {
                p[i].kind = ' ';
                break;
            }
        }
        right = panduan(b_row, b_column + 1, size, p);
    }
    return up + down + left + right;
}

int main()
{
    ///*文件重定向，输出测试*/
    //ifstream fin;
    //fin.open("data.in");
    //cin.rdbuf(fin.rdbuf());
    //ofstream out;
    //out.open("data.out");
    //cout.rdbuf(out.rdbuf());
    int r_number = 0, b_row = 0, b_column = 0;        //红方棋字个数，黑方将的位置
    while (cin >> r_number >> b_row >> b_column&&r_number != 0 && b_column != 0 && b_row != 0)
    {
        auto p = new qizhi[r_number];
        for (int i = 0; i < r_number; ++i)
        {
            cin >> p[i].kind >> p[i].row >> p[i].column;
        }
        if (yes_or_no(b_row, b_column, r_number, p))
            cout << "NO" << endl;
        else
            cout << "YES" << endl;
        delete[] p;

    }


}

　　前面的题目的一些代码在gihub的仓库里https://github.com/YinAoXiong/Algorithmic-exercises，（全部都是用vs2015写的工程文件，源文件在同名的子目录目录中）。如有不对的地方欢迎大家评论指正,这里是我在github上的一个博客，感兴趣的可以去看一下哦。

尹傲雄
关注
专栏目录
uva1589象棋
qiweigo的专栏
02-03 6728
背景：这道题战线拉得最久，每次一到写这道题的时候都有事，导致我写了4天，调试了三个上午，wrong得我想哭，最后历时15个多小时，我终于ac了。 错因：这道题主要是有很多种情况，要考虑完所有的情况，得需要自己无限出数据。 思路：我的思路是用两个字符型数组模拟整个棋盘，一个模拟那个残局，一个模拟红方的棋子能到达的地方，即使帅模拟的地方有些是不符合象棋规则的，但是把帅当成车来用的话，在关键的地方是
UVA 1589 象棋
u012861792的博客
08-22 242
这道题简直是太坑了。一开始在本机上测试怎么都对，但是提交之后无论如何都过不了，简直是要绝望。到最后尝试了一下把%c+getchar()换成了%s之后，终于成功AC。太坑了…………………… #include&amp;amp;amp;lt;cstdio&amp;amp;amp;gt; #include&amp;amp;amp;lt;cstring&amp;amp;amp;gt; using namespace std; int boom[11][11],p[11][11];
Uva - 1589 - Xiangqi
anpi3191的博客
06-10 122
Xiangqi is one of the most popular two-player board games in China. The game represents a battle between two armies with the goal of capturing the enemy’s “general” piece. In this problem, y...
UVA-1589 象棋(Xiangqi)
最新发布
qq_55069195的博客
07-28 441
【代码】UVA-1589 象棋(Xiangqi)
UVa1589
我爱coding的专栏
06-15 958
/* 题意很简单，就是黑方只剩下一个将，红方还有很多子，而且当前的残局是红方正在将军，判断红方是否已经将死黑方 红方只有四种棋子，帅，车，炮，马，因此按照每个棋子的运算规则，即可判断出红方已经能吃到的位置 1。给棋子编码，炮是1,马是2,车是3,因为在对将的时候帅的作用和车是一样的，因此把帅也编成3号，按照车处理 2.这中间使用两个棋盘来记录，mp是残局时每个棋子的位置，an记录判断后红方
Xiangqi UVA - 1589
Galaxy_12138的博客
01-28 665
大致说一下意思，一个黑将，然后红方已经将军了，现在轮到黑棋走，问黑棋还有没有活路了。 心路历程： 1.1月26号凌晨开始琢磨的，拿到题写了五十行，走的是把3*3将可以走的格子标记的办法，当时感觉有点问题，后来考虑到吃子的情况，扔了睡觉。 2.好吧，我没睡着，两点多爬起来写了两句思路。 3.周六走了一天的亲戚，写的伪代码，基本确定走点的办法。 4.晚上开始写......，wa，本人比较懒，
UVA - 1589 Xiangqi (象棋)
YiShi's Blog
11-21 2150
题目链接：UVA - 1589 Xiangqi 题目大意： 给定一个象棋残局，黑方只有一个将，红方有帅以及3种可能棋子（车马炮），当前局面合法并保证红方已将军，问是否可以将黑方将死？ 思路： 很简单的一道题，可以对黑将可走的地方进行判断，判断红方是否可以攻击到。或者标记红方所有子可以攻击的点，然后判断黑将可走的坐标中有没有没被标记的。 思路简单，写的过程wrong了好多次，因为好多小细节，
习题4-1 象棋 UVa1589
Skyline
07-28 1417
#define _CRT_SECURE_NO_WARNINGS #include #include #include #include #include #define max 10 #define rise(i,a,b) for(int i = a + 1;i <= b;i++) #define fall(i,a,b) for(int i = a - 1;i >= b; i--) int
象棋（ Xiangqi, ACM/ICPC Fuzhou 2011, UVa1589）
weixin_40101530的博客
11-18 593
原题连接uva1589 提交uva,ac 说下解题思路:题中描述的象棋规则和我们平时玩的一样,题目给的条件是,黑方只剩一个将,红方有一个帅,还可能有车马炮,现在红方将军,黑方走,需求是让我门判断红方是否把黑方将死.让黑将走所有可能走的位置,然后判断红方能不能吃掉黑将,如果有一个位置红方所有棋子都吃不到黑将,那么就是没将死,否则就是将死了 1.确定黑方将军能走的所有位置,如果黑将旁边有棋子,那...
UVA-1589-象棋
努力努力再努力x
07-15 619
UVA-1589-象棋
象棋 Uva1589
qq_41786066的博客
11-05 322
在网上看到的超棒的代码：http://www.cnblogs.com/cumulonimbus/p/5184725.html 自己看完之后又重新码了一遍 QAQ 变量命名有些窒息 思路：模拟黑棋可以移动到的位置，如果每个位置都被红棋将死，则黑棋已被将死。 #include &lt;stdio.h&gt; #include &lt;string.h&gt; //红方可能棋子 车（R）马（H）...
UVA1589
02-19 132
这道有关象棋的题目是真的恶心，一个月之前做的时候w到怀疑人生。 主要集中 在下面几个方面，第一个就是一定要使用row，col而不要去使用x，y 第二个就是绝对不要使用scanf（“%c”），如果想要输入字符，直接用字符串代替就好 先来总结一下我自己的思路， 分别判断将军在四个可以走的位置上是不是安全的。 在判断的时候，先判断是不是在palace中（is_palace() 一般这...
uva 1589
weixin_30802273的博客
09-22 84
题目大意就是： 一个象棋残局，红方有n（2<=n<=7） 个棋子，黑方只有一个将，红方除了帅，还可能有车，马，炮，并且要考虑“蹩马腿”，输入所有棋子的位置，保证局面合法并且红方已经将军，判断红方是否已经将黑方将死， 解题思路： 用一个棋盘保存红方可以打到的地方，看黑方将是否有其余的地方去，在竖直方向只要判断将能去的大方就可以，也就可以将帅和车一起判断...
Uva 1589 xiangqi
shinimashzi
04-03 260
模拟是否将死的局面。 马 ： 向各个方向先走两步，再往垂直与这个方向上走一步，若这个方向的第一个位置有棋子，则这个方向上不能走。炮： 直线方向上的第一个棋子和第二个棋子之间的位置都可以吃。车： 上下左右将/帅： 不能见面，若是见面，使它们见面的那一方输，所以开始时要特判一下，如果此时将帅见面了，则是黑方输，输出NO这里特别注意的是，将是可以吃棋子的，也即是可以有将先吃了一颗红方的棋，然后另外的棋子
UVA - 1589 Xiangqi
weixin_42547447的博客
11-28 465
传送门：UVA-1589 黑棋可能直接吃掉红棋 这题早该AC的，一个bug卡了好久。。。一直以为if后面如果只有一句（循环也算？）就不用加花括号，但是我代码里写的judge函数的if else里都是循环，不加花括号就一直wa，加了就过。。。有大佬能解释下吗 AC代码：   #include&lt;iostream&gt; #include&lt;vector&gt; #include&l...
UVA - 1589（模拟题）
积少成多，水滴石穿
03-13 255
UVA - 1589 题意： 给出象棋棋盘是10*9的矩阵，每个棋子在交点上，模拟红色棋子是否对黑色棋子将军了。 先输入n，表示将要输入红色棋子的数量，再输入x，y分别比表示黑色将棋子的横纵坐标。 然后n行，ch表示红色棋子的种类，x，y表示这个棋子的坐标。 如果将军：就是黑色棋子的将无论怎么移动都会被红色棋子吃掉。 输入保证棋子的当前状态是合法的且有黑色棋子恰好能够被红色棋子吃...
C语言实现中国象棋
"C语言实现的中国象棋程序" 在C语言中编写中国象棋游戏是一项具有挑战性的任务，因为象棋规则复杂，涉及到棋子的移动规则、吃子逻辑以及胜负判断等多个方面。这个程序使用二维数组来表示棋盘，每个元素代表一个位置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值