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

您有两种选择。

您可以通过将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()。

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

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

1 个答案: