习题4-1 UVa1589-Xiangqi（WA ）

于 2020-03-26 20:14:14 发布
阅读量189 收藏
点赞数
分类专栏： WA 第4章 函数和递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21606413/article/details/105126659
版权

我的思路是，使用两个二维数组chess和check分别记录棋盘上棋子的位置和红棋的攻击范围，再判断黑方将棋的活动区域是否可以被攻击到，如果全都会被攻击，则将死。
记录一下过程中犯的错误：

  1. 如果起始状态黑红将棋在同一条线上并且中间没有其他棋子，这种情况是没有将死的，因为黑方将棋可以“flying general”，直接吃掉红方帥棋。
  2. 車、炮、帥的攻击范围的判断有相似的地方。以車为例，它的攻击范围是整条直线，但一旦遇到其他棋子就要停止。要注意的地方是，这颗棋子所在的地方也是会被車攻击到的，在判断攻击范围时不能忽略。炮、帥同理。
  3. 黑方将棋在移动时是可以吃掉红方棋子的。

题目链接：UVa 1589

由于代码量太多，多次提交报WA后实在没有耐心继续调试了。所以把代码存到这里，日后翻到再做调试：
（如果有好心的大佬看到愿意帮忙找一下问题也是极好的，先在此谢过！！）

#include <iostream>
#include <cstring>
#include <ctype.h>
using namespace  std;
char chess[15][15];
int check[15][15];
int r[15];
int c[15];
int r1[15];
int c1[15];
int flag = 1;
bool face = 0;
bool horse(int x, int y, int a, int b) {   //由于馬要考虑的情况太多了，写出来太冗长
	if (x == 1) {                          //所以改为根据黑方“将”棋的位置来判断馬是否能攻击到它
		if ((((a == x + 1 && b == y - 2) || (a == x + 2 && b == y - 1)) && (!isalpha(chess[x + 1][y - 1]))) || (((a == x + 1 && b == y + 2) || (a == x + 2 && b == y + 1)) && (!isalpha(chess[x + 1][y + 1]))))
			return true;
	}
	else if (x == 2) {
		if ((((a == x + 1 && b == y - 2) || (a == x + 2 && b == y - 1)) && (!isalpha(chess[x + 1][y - 1]))) || (((a == x + 1 && b == y + 2) || (a == x + 2 && b == y + 1)) && (!isalpha(chess[x + 1][y + 1]))))
			return true;
		else if ((a == x - 1 && b == y - 2) && !isalpha(chess[x - 1][y - 1]))
			return true;
		else if ((a == x - 1 && b == y + 2) && !isalpha(chess[x - 1][y + 1]))
			return true;
	}
	else if (x == 3) {
		if ((((a == x + 1 && b == y - 2) || (a == x + 2 && b == y - 1)) && (!isalpha(chess[x + 1][y - 1]))) || (((a == x + 1 && b == y + 2) || (a == x + 2 && b == y + 1)) && (!isalpha(chess[x + 1][y + 1]))))
			return true;
		else if ((((a == x - 1 && b == y - 2) || (a == x - 2 && b == y - 1)) && (!isalpha(chess[x - 1][y - 1]))) || (((a == x - 1 && b == y + 2) || (a == x - 2 && b == y + 1)) && (!isalpha(chess[x - 1][y + 1]))))
			return true;
	}
	return false;
}
void attack(int x, int y, int n) {   //攻击范围的判断函数
	for (int i = 0; i <= n; i++) {
		if (r[i] == x && c[i] == y)
			continue;
		if (chess[r[i]][c[i]] == 'R') {   //車的攻击范围
			if (r[i] + 1 <= 10) {
				for (int j = r[i] + 1; j <= 10; j++) {
					if (!isalpha(chess[j][c[i]]))
						check[j][c[i]] = 1;
					else {
						check[j][c[i]] = 1;
						break;
					}
				}
			}
			if (r[i] - 1 >= 0) {
				for (int j = r[i] - 1; j >= 0; j--) {
					if (!isalpha(chess[j][c[i]]))
						check[j][c[i]] = 1;
					else {
						check[j][c[i]] = 1;
						break;
					}
				}
			}
			if (c[i] - 1 >= 0) {
				for (int j = c[i] - 1; j >= 0; j--) {
					if (!isalpha(chess[r[i]][j]))
						check[r[i]][j] = 1;
					else {
						check[r[i]][j] = 1;
						break;
					}
				}
			}
			if (c[i] + 1 <= 9) {
				for (int j = c[i] + 1; j <= 9; j++) {
					if (!isalpha(chess[r[i]][j]))
						check[r[i]][j] = 1;
					else {
						check[r[i]][j] = 1;
						break;
					}
				}
			}
		}
		if (chess[r[i]][c[i]] == 'G') {   //帥的攻击范围
			if (c[i] == y)
				face = 1;
			for (int j = r[i] - 1; j >= 0; j--) {
				if (!isalpha(chess[j][c[i]])) {
					check[j][c[i]] = 1;
				}
				else {
					if (j == x)
						check[j][c[i]] = 1;
					else
						break;
				}
			}
		}
		if (chess[r[i]][c[i]] == 'C') {   //炮的攻击范围
			int cnt = 0, tip = 0;
			if (r[i] + 1 <= 10)
				for (int j = r[i] + 1; j <= 10; j++) {
					if (isalpha(chess[j][c[i]]) && chess[j][c[i]] != 'G')
						cnt++;
					if (cnt == 0)
						continue;
					if (cnt == 1) {
						int cnt1 = 0;
						while (++j <= 10) {
							if (!isalpha(chess[j][c[i]]))
								check[j][c[i]] = 1;
							else {
								if (cnt1 == 0) {
									cnt1 = 1;
									check[j][c[i]] = 1;
								}
								else {
									tip = 1;
									break;
								}
							}
						}
					}
					if (tip)
						break;
				}
			cnt = 0, tip = 0;   //重置判断标志
			if (r[i] - 1 >= 0)
				for (int j = r[i] - 1; j >= 0; j--) {
					if (isalpha(chess[j][c[i]]) && chess[j][c[i]] != 'B')
						cnt++;
					if (cnt == 0)
						continue;
					if (cnt == 1) {
						int cnt1 = 0;
						while (--j >= 0) {
							if (!isalpha(chess[j][c[i]]))
								check[j][c[i]] = 1;
							else {
								if (cnt1 == 0) {
									cnt1 = 1;
									check[j][c[i]] = 1;
								}
								else {
									tip = 1;
									break;
								}
							}
						}
					}
					if (tip)
						break;
				}
			cnt = 0, tip = 0;
			if (c[i] + 1 <= 9)
				for (int j = c[i] + 1; j <= 9; j++) {
					if (isalpha(chess[r[i]][j]))
						cnt++;
					if (cnt == 0)
						continue;
					if (cnt == 1) {
						int cnt1 = 0;
						while (++j <= 9) {
							if (!isalpha(chess[r[i]][j]))
								check[r[i]][j] = 1;
							else {
								if (cnt1 == 0) {
									cnt1 = 1;
									check[r[i]][j] = 1;
								}
								else {
									tip = 1;
									break;
								}
							}
						}
					}
					if (tip)
						break;
				}
			cnt = 0, tip = 0;
			if (c[i] - 1 >= 0)
				for (int j = c[i] - 1; j >= 0; j--) {
					if (isalpha(chess[r[i]][j]))
						cnt++;
					if (cnt == 0)
						continue;
					if (cnt == 1) {
						int cnt1 = 0;
						while (--j >= 0) {
							if (!isalpha(chess[r[i]][j]))
								check[r[i]][j] = 1;
							else {
								if (cnt1 == 0) {
									cnt1 = 1;
									check[r[i]][j] = 1;
								}
								else {
									tip = 1;
									break;
								}
							}
						}
					}
					if (tip)
						break;
				}
		}
	}
}
bool ischeck(int x, int y, int n) {   //判断黑方“将”棋是否被将死
	int hor = 0;
	if (face) {
		bool facing = 1;   //判断输入的状态下黑红双方将棋是否能“见面”
		for (int j = x + 1; j <= 10; j++) {
			if ((isalpha(chess[j][y])) && chess[j][y] != 'G') {
				facing = 0;
				break;
			}
		}
		if (facing)
			return false;
	}
	for (int i = 0; i < n; i++) {   //统计棋盘上馬的数量，根据数量计算是否将死
		if (chess[r[i]][c[i]] != 'H')
			continue;
		else {
			r1[hor] = r[i];
			c1[hor] = c[i];
			hor++;
		}
	}
	if (!hor) {   //如果棋盘上没有馬，则不必调用horse函数
		if (x == 2 && y == 5) {
			if ((check[2][4] != 1) || (check[2][6] != 1) || (check[1][5] != 1) || (check[3][5] != 1))
				return false;
		}
		else if (x == 2) {
			if ((check[1][y] != 1) || (check[3][y] != 1))
				return false;
		}
		else if (y == 5) {
			if ((check[x][4] != 1) || (check[x][6] != 1))
				return false;
		}
		else {
			if ((check[2][y] != 1) || (check[x][5] != 1))
				return false;
		}
		return true;
	}
	else {
		while (hor--) {
			if (x == 2 && y == 5) {
				if (((check[2][4] != 1) && (!horse(2, 4, r1[hor], c1[hor]))) || ((check[2][6] != 1) && (!horse(2, 6, r1[hor], c1[hor]))) || ((check[1][5] != 1) && (!horse(1, 5, r1[hor], c1[hor]))) || ((check[3][5] != 1) && (!horse(1, 5, r1[hor], c1[hor]))))
					return false;
			}
			else if (x == 2) {
				if (((check[1][y] != 1) && (!horse(1, y, r1[hor], c1[hor]))) || ((check[3][y] != 1) && (!horse(3, y, r1[hor], c1[hor]))))
					return false;
			}
			else if (y == 5) {
				if (((check[x][4] != 1) && (!horse(x, 4, r1[hor], c1[hor]))) || ((check[x][6] != 1) && (!horse(x, 6, r1[hor], c1[hor]))))
					return false;
			}
			else {
				if (((check[2][y] != 1) && (!horse(2, y, r1[hor], c1[hor]))) || ((check[x][5]) != 1) && (!horse(x, 5, r1[hor], c1[hor])))
					return false;
			}
			return true;
		}
	}
	return false;
}
int main() {
	int n, a, b;
	char ch;
	memset(chess, '0', sizeof(chess));
	memset(check, 0, sizeof(check));
	while (cin >> n && n != 0) {
		int cha = 0, hor = 0, can = 0, m = 0, p = n;
		cin >> a >> b;
		r[m] = a; c[m] = b;
		m++;
		chess[a][b] = 'B';
		while (n--) {
			cin >> ch >> a >> b;
			r[m] = a; c[m] = b;
			m++;
			chess[a][b] = ch;
		}
		attack(r[0], c[0], p);
		/*for (int i = 1; i < 11; i++) {
			for (int j = 1; j < 10; j++) {
				cout << chess[i][j];
			}
			cout << endl;
		}
		cout << endl;
		for (int i = 1; i < 11; i++) {
			for (int j = 1; j < 10; j++) {
				cout << check[i][j];
			}
			cout << endl;
		}*/
		bool flag = ischeck(r[0], c[0], p);
		if (flag)
			cout << "YES" << endl;
		else
			cout << "NO" << endl;
		memset(chess, '0', sizeof(chess));
		memset(check, 0, sizeof(check));
	}
	return 0;
}
徹夜禁止
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
uva 50个题解
07-22
有uva刘汝佳文件夹的50道题解，从数据结构开始，以后慢慢上传
XiangQi Engine-开源
04-27
《开源XiangQi Engine：构建中国象棋游戏的智慧核心》 中国象棋，作为深受中华文化影响的传统棋类游戏，其独特的策略性和丰富的变化吸引了无数爱好者。随着信息技术的发展，将这种传统的智力游戏与现代计算机技术相...
UVA1589 解题报告
qq_40510397的博客
04-28 870
UVA1589曾经想过两种不同的思路：思路1：对红方的每一个棋子，把他们的必杀区域（能吃掉对方的棋子的区域）都用*代替，之后对黑方的帅，试着移动四个方位，如果四个方位都会碰到'*',那么红方将死对方。就是之前要检查一下红方是否会被黑方飞帅直线击杀。思路2：与思路1相反，先移动黑方的帅，对每一个可能移动的方位，遍历所有红方的棋子，看红方棋子能否击杀黑方。如果对四个可能的移动方位，黑方都必死，那么红方...
UVA 1589（模拟）
bixianren9179的博客
02-14 174
  #include &lt;iostream&gt; #include&lt;stdio.h&gt; using namespace std; char m[15][15]; int dx[4] = { 1,-1,0,0 }; int dy[4] = { 0,0,1,-1 }; int cntx(int a, int b, int y) { if (a &gt; b) swap(a,...
xboard-xiangqi_4.9.1-7_all.deb_xboard-xiangqi_
10-01
Linux xboard 上玩中国象棋. DEB package for Debian/Ubuntu/LinuxMint amd64
Python库 | xiangqi-setup-1.4.tar.gz
05-24
资源分类：Python库 所属语言：Python 资源全名：xiangqi-setup-1.4.tar.gz 资源来源：官方 安装方法：https://lanzao.blog.csdn.net/article/details/101784059
Xiangqi-开源
04-26
一款适用于Linux和Windows的中国象棋（象棋）游戏。 旨在快速，灵活并且首先易于使用。 您可以与您的朋友一起玩，也可以与AI对抗。
XiangQi XML-开源
04-26
《XiangQi XML：开源与象棋的数字化革命》 XiangQi XML，这是一个专注于将中国象棋游戏体验推向新高度的开源项目。其核心在于制定了一套基于XML（可扩展标记语言）的标准，旨在全面地捕捉、表示、评论、交换和展示...
HDU4121 UVa1589 Xiangqi 解题报告
mukevinran的博客
11-21 814
http://acm.hdu.edu.cn/showproblem.php?pid=4121​ 这是一道模拟的题，大致是中国象棋的规则，然后给你输入红方和黑方的棋子，然后再给出红方的其它棋子，其它棋子只能为 车、马、炮，且棋盘一共只有8个棋子。题目中的情况是，现在轮到黑方来移动棋子，来判断是否已经把黑方的将“将死”。首先读完题目，就知道这是一道模拟题。需要模拟象棋的规则，对棋盘进行操作。而且，我们
Xiangqi UVA - 1589
Galaxy_12138的博客
01-28 634
大致说一下意思，一个黑将，然后红方已经将军了，现在轮到黑棋走，问黑棋还有没有活路了。 心路历程： 1.1月26号凌晨开始琢磨的，拿到题写了五十行，走的是把3*3将可以走的格子标记的办法，当时感觉有点问题，后来考虑到吃子的情况，扔了睡觉。 2.好吧，我没睡着，两点多爬起来写了两句思路。 3.周六走了一天的亲戚，写的伪代码，基本确定走点的办法。 4.晚上开始写......，wa，本人比较懒，
Uva 1589 xiangqi
shinimashzi
04-03 234
模拟是否将死的局面。 马 ： 向各个方向先走两步，再往垂直与这个方向上走一步，若这个方向的第一个位置有棋子，则这个方向上不能走。炮： 直线方向上的第一个棋子和第二个棋子之间的位置都可以吃。车： 上下左右将/帅： 不能见面，若是见面，使它们见面的那一方输，所以开始时要特判一下，如果此时将帅见面了，则是黑方输，输出NO这里特别注意的是，将是可以吃棋子的，也即是可以有将先吃了一颗红方的棋，然后另外的棋子
象棋 UVa1589
尹傲雄的博客
03-27 798
看到这个题目基本的想法是，将黑将能走的四个方向都遍历一遍，然后再判断判断红方能否吃掉它。如果所有可能的走向都会被将死，则黑将被将死。需要注意越界，吃子，和马被别脚的情况。附上一张自己画的一张简图可能会清楚一些： 　　 下面贴一下代码，更详细的解释在代码的注释里，代码有点冗长，有能力的可以把相同的地方写成函数（比如说帅和车的判断是可以放一起的） #include #include usin
UVa1589 象棋
Moyu的专栏
02-27 192
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4121 思路：找出黑将下一步可能的位置，判断该位置是否可被红方攻击。 错误1：没考虑黑将移动吃红子问题 错误2：没考虑给出的输入黑将可以直接杀红帅 错误3：输入字符问题（可能OJ系统输入有问题，总是导致超时）。 代码实现： #include&lt;iostream&gt; #include...
uva1589象棋
qiweigo的专栏
02-03 6721
背景：这道题战线拉得最久，每次一到写这道题的时候都有事，导致我写了4天，调试了三个上午，wrong得我想哭，最后历时15个多小时，我终于ac了。 错因：这道题主要是有很多种情况，要考虑完所有的情况，得需要自己无限出数据。 思路：我的思路是用两个字符型数组模拟整个棋盘，一个模拟那个残局，一个模拟红方的棋子能到达的地方，即使帅模拟的地方有些是不符合象棋规则的，但是把帅当成车来用的话，在关键的地方是
uva 1589 - Xiangqi（象棋）
SuCicada 小米的蝉
02-26 632
习题4-1 象棋（Xiangqi, ACM/ICPC Fuzhou 2011, UVa1589） 考虑一个象棋残局，其中红方有n（2≤n≤7）个棋子，黑方只有一个将。红方除了有一个 帅（G）之外还有3种可能的棋子：车（R），马（H），炮（C），并且需要考虑“蹩马 腿”（如图4-4所示）与将和帅不能照面（将、帅如果同在一条直线上，中间又不隔着任何棋 子的情况下，走子的一方获胜）

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值