如何使用 alpha-beta 修剪构建游戏树

Question

我正在尝试为我的游戏构建一个游戏树，以便找到我的下一步行动。 首先，我使用递归算法构建树，然后，使用 alpha - beta 剪枝算法找到最佳移动 Im。 我想使用 alpha - beta 修剪来构建游戏树，以最小化游戏树的大小，但我在编写算法时遇到问题。 你能帮我在扩展算法中添加 alpha - beta 剪枝吗？

这里是展开算法：

public void expand(int depth) 
    {
        expand++;
        if(depth > 0)
        {
            this.children = new ArrayList<GameTreeNode>();
            List<Move> possibleMoves = this.b.possibleMoves(this.b.turn);

            ReversiBoard tmp = null;

            for(Move m : possibleMoves)
            {
                TurnState nextState = (this.state == TurnState.PLUS ? TurnState.MINUS : TurnState.PLUS);
                tmp = new ReversiBoard(this.b);
                tmp.makeMove(m);
                int nextTurn = (turn == PLAYER1 ? PLAYER2 : PLAYER1);
                if(tmp.possibleMoves(nextTurn).isEmpty())
                    nextTurn = turn;
                this.children.add(new GameTreeNode(tmp, nextState, m, nextTurn));

                for(GameTreeNode child : children)
                        child.expand(depth - 1);
            }
        }
    }

这是 alpha - beta 修剪代码：

int alphaBetaMax( int alpha, int beta, int depthleft ) {
        alphaBetaNum++;
           if ( depthleft == 0 ) return this.b.evaluate();
           for (GameTreeNode tree : this.children) {
              bestValue = alphaBetaMin( alpha, beta, depthleft - 1 );
              if( bestValue >= beta )
              {
                 bestMove = tree.move;

                 return beta;   // fail hard beta-cutoff
              }
              if( bestValue > alpha )
                 alpha = bestValue; // alpha acts like max in MiniMax
           }
           return alpha;
        }

        int alphaBetaMin( int alpha, int beta, int depthleft ) {
            alphaBetaNum++;
           if ( depthleft == 0 ) return -this.b.evaluate();
           for ( GameTreeNode tree : this.children) {
              bestValue = alphaBetaMax( alpha, beta, depthleft - 1 );
              if( bestValue <= alpha )
              {
                  bestMove = tree.move;
                 return alpha; // fail hard alpha-cutoff
              }
              if( bestValue < beta )
                 beta = bestValue; // beta acts like min in MiniMax
           }
           return beta;
        }

        public void summonAlphaBeta(int depth)
        {
            this.bestValue  = alphaBetaMax(Integer.MIN_VALUE, Integer.MAX_VALUE, depth);
        }

谢谢！

Answer 1

你有两个选择。

1. 您可以通过将expand 方法转换为expandAndReturnMin 和expandAndReturnMax 方法来组合这两种算法，每个方法都将alpha 和beta 值作为参数。理想情况下，任何共享代码都将被放入第三种方法中，以保持代码干净。

这里有一些示例代码供您考虑。在此示例中，我假设静态成员正在存储最佳移动。

public int bestValue(Board board, int depth, int alpha, int beta, boolean aiPlayer) {
    if (depth >= MAX_DEPTH || board.possibleMoves(aiPlayer).isEmpty()) {
        return board.getValue();
    } else {
        for (Move move: board.possibleMoves(aiPlayer) {
            int value = bestValue(board.makeMove(move), depth + 1, alpha, beta, !aiPlayer);
            if (aiPlayer && value > alpha) {
                alpha = value;
                bestMove = move;
                if (alpha >= beta)
                    break;
            } else if (!aiPlayer && value < beta) {
                beta = value;
                bestMove = move;
                if (beta >= alpha)
                    break;
            }
        }
        return aiPlayer ? alpha : beta;
    }
}

最佳初始移动由以下因素决定： board.bestValue(board, 0, Integer.MIN_VALUE, Integer.MAX_VALUE, true); 然后使用board.getBestMove()。

1. 更优雅的解决方案是将 alpha 和 beta 值存储在树本身中。这很简单：在生成每个子节点后，更新当前节点中的值。然后，如果它们超出允许范围，您可以停止生成子节点。这是更标准的方法，计算成本低，但会使节点使用更多内存。