Question

我正在尝试使用alpha beta修剪实现国际象棋游戏。以下几乎可以正常工作，但它会返回错误的动作。

例如，可能会发生以下情况。

白色（用户）移动，白色王位置 - a1 /黑色（电脑），黑色王位置 - h1

怀特从a1 - a2移动它的王，然后黑色返回移动g2 - g1 ???

Example

计算机似乎返回错误节点的移动（电路板表示），就好像给定电路板位置的最佳评估没有一直传播到树上。因此，在一个被探索的模拟位置中，计算机＆＃34;想象＆＃34;它的王移动到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的bounderies来调用min / max进行下一次移动。这样，您的算法就不会从以前的动作中“学习”。

你需要的是再次检查算法（例如维基百科，我使用的），并看到他们使用前评估修改的alpha和beta。这样，更高深度的计算可以首先停止，然后更好地评估最佳移动。

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

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

也不要使用两个国王进行评估。没有目标。两位国王是随机的，不能赢。有一件事可能是两个骑士或四个皇后等。它不是那么随意，你可以看到女王们在不能相互捕捉的情况下四处跳舞。或者使用三个骑士而不是一个女王。

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

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

国际象棋alpha测试版为董事会带来了错误的举动

1 个答案: