UVa 10838 The Pawn Chess

原创于 2025-12-15 08:24:14 发布 · 985 阅读

12 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #青少年编程

回溯法专栏收录该内容

48 篇文章

订阅专栏

题目翻译

考虑以下简化版国际象棋：我们有一个 $\times 4$ 的棋盘，第一行（输入中的最下方）有四个白兵，最后一行（输入中的最上方）有四个黑兵。游戏的目标是让自己的一个兵走到对方底线（白方走到最后一行，黑方走到第一行），或者逼对手无棋可走（即“困毙”）。当轮到某玩家走棋时，若他没有合法走法（包括所有兵已被吃光），则他被困毙。

兵的走法与普通国际象棋相同，但 不能一次走两步 。即：

兵可以向前（朝向对方底线）走一步，前提是目标格为空。
兵也可以吃掉对方兵，如果对方兵位于其左前方或右前方（斜前方一格）。被吃的兵从棋盘移除。

给定棋盘上兵的位置，假设双方都采取最优策略，判断谁会获胜。同时需要计算游戏结束前会进行的步数（假设获胜方会尽快获胜，输的一方会尽可能拖延）。输入局面总是轮到白方走子。

输入格式

第一行输入测试用例数（最多 $50$ 个）。每个用例包含四行描述棋盘，前面有一个空行。四行中的第一行表示棋盘的最后一行（黑兵的起始位置）。黑兵用 p 表示，白兵用 P 表示，空位用 . 表示。每方有 $1$ 到 $4$ 个兵。初始局面不会是终局局面，且白方至少有一个合法走子。注意：输入局面不一定是从初始局面合法走出来的。

输出格式

对于每个测试用例，输出一行：

如果白方赢，输出 white (xx)
如果黑方赢，输出 black (xx)

其中 xx 是步数（白方赢时步数为奇数，黑方赢时为偶数）。

题目分析与解题思路

本题是一个双方零和博弈问题，棋盘大小固定为 $\times 4$ ，每方最多 $4$ 个兵，状态空间有限，适合用 极小化极大算法（ $Minimax\texttt{Minimax}$ ） 配合 记忆化搜索 解决。

核心思路

状态表示
棋盘共有 $16$ 格，每格有三种状态：空、白兵、黑兵。可以用 $2$ 位二进制表示一格（ $00$ 空， $01$ 白兵， $10$ 黑兵），整个棋盘用一个 $64$ 位整数（ unsigned long long ）表示。另外还需要记录当前轮到谁走（ $0$ 白方， $1$ 黑方）。
胜负判定
- 白方赢：任意白兵到达第 $0$ 行（黑方底线）。
- 黑方赢：任意黑兵到达第 $3$ 行（白方底线）。
- 若当前玩家无合法走法（包括无兵可走），则对方赢。
走法生成
根据当前玩家（白方或黑方）遍历所有兵：
- 向前走：检查目标格是否在棋盘内且为空。
- 吃子：检查左前、右前（对白方是行减 $1$ ，对黑方是行加 $1$ ）是否有对方兵。
搜索策略（ $Minimax\texttt{Minimax}$ ）
设 $so l v e (s t a t e, t u r n)$ 返回（赢家，从当前状态到游戏结束的步数），其中 $t u r n = 0$ 表示白方走， $t u r n = 1$ 表示黑方走。
- 终止条件：出现胜负局面或无棋可走。
- 递归过程：
  - 生成所有合法走法。
  - 对每个走法递归调用 $\oplus 1)$ 。
  - 如果 当前玩家能赢 ，则选择 步数最少 的走法（尽快赢）。
  - 如果 当前玩家会输 ，则选择 步数最多 的走法（拖延）。
记忆化
用哈希表缓存 $(s t a t e, t u r n)$ 的结果，避免重复计算。

算法流程

读入棋盘，转换为 $64$ 位状态码。
调用 $so l v e (s t a t e, 0)$ （白方先走）。
根据返回的赢家和步数输出结果。

复杂度分析

状态数：每格 $3$ 种状态，最多 $316≈4.3×1073^{16} \approx 4.3 \times 10^7$ ，但实际可达状态远少于这个数（每方最多 $4$ 个兵）。
每个状态生成走法最多 $\times 3 = 12$ 种（ $4$ 个兵，每个兵最多 $3$ 种走法：向前、左吃、右吃）。
记忆化后，每个状态只计算一次，整体在时间和空间上均可接受。

代码实现

// The Pawn Chess
// UVa ID: 10838
// Verdict: Accepted
// Submission Date: 2025-12-14
// UVa Run Time: 0.000s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

#include <bits/stdc++.h>
using namespace std;

// 棋盘编码：每格 2 位，共 16 格，64 位整数存储
// 00: 空, 01: 白兵(P), 10: 黑兵(p)
const int WHITE = 1, BLACK = 2;
const int INF = 1e9;

// 方向：白兵向上(row-1)，黑兵向下(row+1)
const int WHITE_DIR = -1, BLACK_DIR = 1;
const int CAPTURE_DIRS[2][2] = {{-1, -1}, {-1, 1}}; // 白兵吃子方向（左上、右上）
const int BLACK_CAPTURE_DIRS[2][2] = {{1, -1}, {1, 1}}; // 黑兵吃子方向（左下、右下）

// 记忆化缓存：map<状态, pair<结果, 步数>>
unordered_map<unsigned long long, pair<int, int>> memo[2]; // 0:白方走, 1:黑方走

// 从状态中获取某格的值
int getCell(unsigned long long state, int r, int c) {
    int pos = (r * 4 + c) * 2;
    return (state >> pos) & 3;
}

// 设置某格的值
void setCell(unsigned long long& state, int r, int c, int val) {
    int pos = (r * 4 + c) * 2;
    state &= ~(3ULL << pos);
    state |= ((unsigned long long)val << pos);
}

// 判断是否到达底线
bool isWhiteWin(unsigned long long state) {
    for (int c = 0; c < 4; ++c)
        if (getCell(state, 0, c) == WHITE) return true; // 白兵到达第0行（黑方底线）
    return false;
}

bool isBlackWin(unsigned long long state) {
    for (int c = 0; c < 4; ++c)
        if (getCell(state, 3, c) == BLACK) return true; // 黑兵到达第3行（白方底线）
    return false;
}

// 生成所有合法走法
vector<pair<unsigned long long, int>> generateMoves(unsigned long long state, int turn) {
    vector<pair<unsigned long long, int>> moves;
    int player = (turn == 0) ? WHITE : BLACK;
    int dir = (turn == 0) ? WHITE_DIR : BLACK_DIR;

    for (int r = 0; r < 4; ++r) {
        for (int c = 0; c < 4; ++c) {
            if (getCell(state, r, c) != player) continue;

            // 向前走一步
            int nr = r + dir;
            if (nr >= 0 && nr < 4 && getCell(state, nr, c) == 0) {
                unsigned long long next = state;
                setCell(next, r, c, 0);
                setCell(next, nr, c, player);
                moves.push_back({next, 1});
            }

            // 吃子
            auto& capDirs = (turn == 0) ? CAPTURE_DIRS : BLACK_CAPTURE_DIRS;
            for (auto& d : capDirs) {
                int nr = r + d[0];
                int nc = c + d[1];
                if (nr >= 0 && nr < 4 && nc >= 0 && nc < 4) {
                    int target = getCell(state, nr, nc);
                    if (target != 0 && target != player) {
                        unsigned long long next = state;
                        setCell(next, r, c, 0);
                        setCell(next, nr, nc, player);
                        moves.push_back({next, 1});
                    }
                }
            }
        }
    }
    return moves;
}

// Minimax 搜索，返回 (胜负, 步数)
pair<int, int> solve(unsigned long long state, int turn) {
    // 检查缓存
    if (memo[turn].count(state)) return memo[turn][state];

    // 终局判断
    if (isWhiteWin(state)) return {0, 0}; // 白方赢，步数为0（当前还未走）
    if (isBlackWin(state)) return {1, 0}; // 黑方赢

    auto moves = generateMoves(state, turn);
    if (moves.empty()) {
        // 当前玩家无棋可走，对方赢
        if (turn == 0) return {1, 0}; // 白方无棋，黑方赢
        else return {0, 0}; // 黑方无棋，白方赢
    }

    int bestWinner = -1;
    int bestSteps = INF;
    int worstSteps = -1;

    for (auto& mv : moves) {
        auto res = solve(mv.first, turn ^ 1);
        int winner = res.first;
        int steps = res.second + mv.second; // 加上这一步

        if (bestWinner == -1) {
            bestWinner = winner;
            bestSteps = steps;
            worstSteps = steps;
        } else {
            if (winner == turn) {
                // 当前玩家能赢，取最短步数
                if (winner == bestWinner) bestSteps = min(bestSteps, steps);
                else {
                    bestWinner = winner;
                    bestSteps = steps;
                }
            } else {
                // 当前玩家会输，取最长步数（拖延）
                if (bestWinner == winner) worstSteps = max(worstSteps, steps);
                else {
                    // 如果之前有赢的可能，保留赢法
                    if (bestWinner != turn) {
                        bestWinner = winner;
                        worstSteps = steps;
                    }
                }
            }
        }
    }

    int finalSteps = (bestWinner == turn) ? bestSteps : worstSteps;
    memo[turn][state] = {bestWinner, finalSteps};
    return {bestWinner, finalSteps};
}

int main() {
    int T;
    cin >> T;
    while (T--) {
        vector<string> board(4);
        for (int i = 0; i < 4; ++i) {
            cin >> board[i];
            // 处理可能的空格（样例中有空格，但实际输入可能没有）
            if (board[i].size() < 4) board[i] = "....";
        }

        // 构建状态
        unsigned long long state = 0;
        for (int r = 0; r < 4; ++r) {
            for (int c = 0; c < 4; ++c) {
                int val = 0;
                if (board[r][c] == 'P') val = WHITE;
                else if (board[r][c] == 'p') val = BLACK;
                setCell(state, r, c, val);
            }
        }

        // 初始化缓存
        memo[0].clear();
        memo[1].clear();

        auto res = solve(state, 0);
        int winner = res.first;
        int steps = res.second;

        if (winner == 0) cout << "white (" << steps << ")\n";
        else cout << "black (" << steps << ")\n";
    }
    return 0;
}