国际象棋阿尔法贝塔向棋盘返回错误的移动

Question

我试图实现一个带有alpha beta修剪的国际象棋游戏。以下几乎可以工作，但它返回错误的动作。

例如，可以出现以下情况。

白色（用户）移动，白色国王位置-a1/黑色（计算机），黑色国王位置-h1

白色从a1-a2移动其国王，然后黑色返回移动g2-g1？？？

计算机似乎返回了错误节点的移动（电路板表示），就好像给定电路板位置的最佳评估没有一直传播到树的后面。因此，在探索的一个模拟位置中，计算机“想象”它的国王移动到g2，然后返回从该位置进行的移动，没有意识到该位置是模拟位置，而不是实际电路板（根节点？）的表示。

如何更正代码以使计算机返回实际董事会表示的移动，而不是错误的模拟之一？

非常感谢。

初始调用alphaBeta（3，ChessEngine.invertBoard（ChessEngine.board），-10000，10000，true）

private static int alphaBetaEvaluate = 0;
private static int alphaBetaSelectedSquare = 0;
private static int alphaBetaMoveToSquare = 0;
public static int alphaBeta(int depth, char[] board, int alpha, int beta, boolean maxPlayer) {

    //create a copy of the board
    char[] boardCopy = board.clone();

    //if terminal state has not been met, keep searching
    if (maxPlayer == true && depth > 0) {

        //for all of the moves that max can make
        for (int i = 0; i < board.length; i++) {
            for (int move : ChessEngine.getValidMoves(i, boardCopy)) {

                //make the move
                boardCopy[move] = boardCopy[i];
                boardCopy[i] = '.';

                alphaBetaEvaluate = rating(board, boardCopy, i, move);

                //store the best move to make
                int temp = alphaBeta(--depth, ChessEngine.invertBoard(boardCopy), -10000, 10000, false);
                if (temp > alpha) {
                    alphaBetaSelectedSquare = i;
                    alphaBetaMoveToSquare = move;           
                    alpha = temp;
                }

                //reset the board for the next simulated move
                boardCopy = board.clone();

                if (beta <= alpha) {
                    break;
                }
            }
        }
        return alpha;
    } else if (maxPlayer == false && depth > 0) {

        //for all of the moves that min can make
        for (int i = 0; i < board.length; i++) {
            for (int move : ChessEngine.getValidMoves(i, boardCopy)) {

                //make the move
                boardCopy[move] = boardCopy[i];
                boardCopy[i] = '.';
                beta = Math.min(beta, alphaBeta(--depth, ChessEngine.invertBoard(boardCopy), -10000, 10000, true));

                //reset the board for the next simulated move
                boardCopy = board.clone();

                if (beta <= alpha) {
                    break;
                }
            }
        }
        return beta;
    }
    return alphaBetaEvaluate;
}

Answer 1

我还是不明白你的想法。首先，你要做的是创建一棵树。一个决策树，并将决策向上传播。你想最大限度地提高你的评估，同时也希望敌人会选择降低你评估的招式作为回报。

所以，对我来说，反转电路板听起来不太合理，除非你知道你对情况的评估是正确的。

对我来说，另一个严重的问题是，你总是在下一步调用最小/最大值，用-10k和10k作为alpha和beta的边界。这样你的算法就不会从之前的动作中“学习”。

你需要的是再次检查算法（例如，我使用的维基百科），看看它们使用的是阿尔法和贝塔法，并根据之前的评估进行了修改。这样，在更高深度的计算可以首先停止，然后更好地评估最佳移动。

我不是这方面的专家。几十年前，当我编写我的实现时，我使用了一些不同的东西。

另一个想法是不要在同一个方法中使用min和max，而是使用min和max方法。这让你更有可能发现其他缺陷。

也不要使用两个国王进行评估。这是没有目标的。两个国王是随机的，不可能赢。有一件事可能是两个骑士或四个皇后之类的。这并不是随机的，你可以看到皇后们在跳舞，却无法抓住对方。或者用三个骑士对抗一个女王。

试着围绕其他部分为自己创建一些单元测试。只是为了确保零件能够独立正常工作。你为什么要使用角色？为什么不使用枚举或对象呢。可以为每个字段重用对象（更像是各种图形）。

但无论如何，这是风格，而不是算法正确性。