题解：UVA1589 象棋 Xiangqi

看到代码别急着走，还要解释呢！

哈哈，知道这个题我是怎么来的吗？

和爸爸下象棋20场输17场+和2场QWQ

于是乎我就想找到一个可以自动帮我下棋的程序，在洛谷上面搜索，就搜索到了这个题。

很好奇UVA的为啥空间限制是0B。

还有，黑棋技术这么垃圾的吗......就剩光杆司令了

正文开始

问题概述

• 给定一个残局，红方已经"将军"（delivered a check）。

• 棋盘大小：10行 x 9列（左上角(1,1)，右下角(10,9)）。

• 黑方只有一个将（general），位置给定。

• 红方有N个棋子（2≤N≤7），包括将（G）、车（R）、炮（C）、马（H）。

• 现在轮到黑方走棋，我们需要判断是否被"将死"（checkmate）。

• 输入以0 0 0结束。

解决思路

1. 理解"将死"：如果黑将无论走到哪个合法位置（上下左右，且必须在黑方九宫格内：行1-3，列4-6），都会被红方棋子攻击到，那么就是"将死"（YES）；否则（存在至少一个安全位置）输出"NO"。

2. 关键点：

   • 黑将的移动：每次只能上下左右移动一格，且必须留在黑方九宫格内（行1-3，列4-6）。

   • 对于黑将的每一个可能的移动位置（最多4个方向），检查该位置是否会被任何一个红方棋子攻击。

   • 如果所有可能的位置都会被攻击，则输出"YES"（将死）；否则输出"NO"。

3. 如何判断一个位置是否被红方棋子攻击？

   • 对于每个红方棋子，根据其类型（G、R、C、H）检查是否能攻击到目标位置（黑将移动后的位置）。

   • 注意：红方棋子可能被其他棋子阻挡（车、炮、将），马有"蹩马腿"规则。

4. 具体规则：

   • 将（G）：只能走一步（上下左右），且必须在红方九宫格（行1-3？实际上红将是在下方，但这里注意"飞将"规则：如果两个将在同一列且中间无棋子，红将可以飞过去攻击黑将）。

     • 检查：如果红将和黑将在同一列，且中间没有其他棋子，则可以攻击。

   • 车（R）：直线移动（横竖），路径上不能有棋子阻挡（除了目标位置）。

     • 检查：如果在同一行或同一列，且中间没有棋子阻挡，则可以攻击。

   • 炮（C）：直线移动，但必须跳过一个棋子（ exactly one piece）才能攻击。

     • 检查：如果在同一行或同一列，且中间恰好有一个棋子（无论敌友），则可以攻击。

   • 马（H）：走"日"字，有8个方向，但马腿位置（马走日的第一步方向）不能有棋子。

     • 检查：对于8个可能的方向，检查马腿位置是否无棋子，且目标位置正好是黑将位置。

5. 实现步骤：

   • 读取输入，存储红方棋子（类型和位置）。

   • 枚举黑将的4个可能的移动方向（上、下、左、右），检查是否在九宫格内。

   • 对于每个候选位置(nx, ny)：

     • 如果该位置有红方棋子（会被吃掉），则跳过？实际上，如果黑将走到该位置吃掉红方棋子，那么该红方棋子就不存在了。所以我们在检查攻击时，应该排除这个被吃掉的棋子（如果存在）。

     • 创建一个棋盘网格（10x9），标记所有红方棋子的位置（除了被吃掉的这个）。

     • 遍历每个红方棋子（除了被吃掉的），检查它是否能攻击到(nx, ny)。

     • 如果任何一个红方棋子能攻击到(nx, ny)，则该位置不安全。

   • 如果存在一个安全位置，则不是将死（输出NO）；否则是将死（输出YES）。

#include <bits/stdc++.h>
using namespace std;
int main() {
	int N, NO_5, NO_70;
	while (cin >> N >> NO_5 >> NO_70) {
		if (N == 0 && NO_5 == 0 && NO_70 == 0) break;
		vector<tuple<char, int, int>> NO_75;
		for (int i = 0; i < N; i++) {
			char NO_78;
			int x, y;
			cin >> NO_78 >> x >> y;
			NO_75.push_back(make_tuple(NO_78, x, y));
		}
		int dx[] = {1, -1, 0, 0};
		int dy[] = {0, 0, 1, -1};
		bool NO_11 = false;
		for (int d = 0; d < 4; d++) {
			int nx = NO_5 + dx[d];
			int ny = NO_70 + dy[d];
			if (nx < 1 || nx > 3 || ny < 4 || ny > 6) continue;
			vector<vector<bool>> NO_64(11, vector<bool>(10, false));
			for (auto& red : NO_75) {
				char NO_78 = get<0>(red);
				int rx = get<1>(red);
				int ry = get<2>(red);
				if (rx == nx && ry == ny) continue;
				NO_64[rx][ry] = true;
			}
			bool NO_85 = false;
			for (auto& red : NO_75) {
				char NO_78 = get<0>(red);
				int rx = get<1>(red);
				int ry = get<2>(red);
				if (rx == nx && ry == ny) continue;
				if (NO_78 == 'G') {
					if (ry != ny) continue;
					int NO_25 = min(rx, nx);
					int NO_95 = max(rx, nx);
					int NO_112 = 0;
					for (int x0 = NO_25 + 1; x0 < NO_95; x0++) {
						if (NO_64[x0][ry]) NO_112++;
					}
					if (NO_112 == 0) {
						NO_85 = true;
						break;
					}
				} else if (NO_78 == 'R') {
					if (rx == nx) {
						int min_y = min(ry, ny);
						int max_y = max(ry, ny);
						int NO_112 = 0;
						for (int y0 = min_y + 1; y0 < max_y; y0++) {
							if (NO_64[rx][y0]) NO_112++;
						}
						if (NO_112 == 0) {
							NO_85 = true;
							break;
						}
					} else if (ry == ny) {
						int NO_25 = min(rx, nx);
						int NO_95 = max(rx, nx);
						int NO_112 = 0;
						for (int x0 = NO_25 + 1; x0 < NO_95; x0++) {
							if (NO_64[x0][ry]) NO_112++;
						}
						if (NO_112 == 0) {
							NO_85 = true;
							break;
						}
					}
				} else if (NO_78 == 'C') {
					if (rx == nx) {
						int min_y = min(ry, ny);
						int max_y = max(ry, ny);
						int NO_112 = 0;
						for (int y0 = min_y + 1; y0 < max_y; y0++) {
							if (NO_64[rx][y0]) NO_112++;
						}
						if (NO_112 == 1) {
							NO_85 = true;
							break;
						}
					} else if (ry == ny) {
						int NO_25 = min(rx, nx);
						int NO_95 = max(rx, nx);
						int NO_112 = 0;
						for (int x0 = NO_25 + 1; x0 < NO_95; x0++) {
							if (NO_64[x0][ry]) NO_112++;
						}
						if (NO_112 == 1) {
							NO_85 = true;
							break;
						}
					}
				} else if (NO_78 == 'H') {
					int NO_99[8][2] = {{2,1}, {2,-1}, {-2,1}, {-2,-1}, {1,2}, {1,-2}, {-1,2}, {-1,-2}};
					int NO_107[8][2] = {{1,0}, {1,0}, {-1,0}, {-1,0}, {0,1}, {0,-1}, {0,1}, {0,-1}};
					for (int i = 0; i < 8; i++) {
						int tx = rx + NO_99[i][0];
						int ty = ry + NO_99[i][1];
						if (tx < 1 || tx > 10 || ty < 1 || ty > 9) continue;
						int hx = rx + NO_107[i][0];
						int hy = ry + NO_107[i][1];
						if (hx < 1 || hx > 10 || hy < 1 || hy > 9) continue;
						if (!NO_64[hx][hy] && tx == nx && ty == ny) {
							NO_85 = true;
							break;
						}
					}
					if (NO_85) break;
				}
			}
			if (!NO_85) {
				NO_11 = true;
				break;
			}
		}
		cout << (NO_11 ? "NO" : "YES") << endl;
	}
	return 0;
}

dx&&dy：黑将可以移动的方向

钠（NO_11）：判断

if (rx == nx && ry == ny) continue:如果这个红子正好在黑将移动的位置上，则会被吃掉，所以不标记（我和AI下象棋就是这样丢了一个砲QWQ）

砹（NO_85）：该位置是否被攻击

if (rx == nx && ry == ny) continue;如果这个红子被吃掉，则跳过

if (count == 0) { 无阻挡，可以攻击

然后就是噼里啪啦一顿程序，分别判断 将 車 炮 马

注意马的撇腿（如果象也加入那么还要撇象眼）。