2 views

I am trying to implement minimax with alpha-beta pruning for a checkers game in Java. My minimax algorithm works perfectly. My code runs with the alpha-beta code in place. Unfortunately, when I play 1000 games vs the standard minimax algorithm, the alpha-beta algorithm always comes out behind by 50 games or so.

Since alpha-beta pruning should not be reducing the quality of the moves, just the time it takes to achieve them, something has to be wrong. However, I have taken out pen and paper and drawn hypothetical leaf node values and used my algorithm to predict whether it will calculate the correct best move, and there doesn't appear to be any logic errors. I used the tree from this video: Alpha-Beta Pruning to trace my algorithm. It logically should make all of the same choices, and therefore be a functioning implementation.

I have also put print statements into the code (they have been removed to reduce the clutter), and values are being returned correctly it appears and pruning does happen. Despite my best efforts, I have been unable to find where the logic error lies. This is my third different attempt at implementing this and all of them have had the same issue.

I can't post the full code here, it's much too long, so I have included the methods that are relevant to the error. I'm not certain, but I suspect the problem may likely be in the non-recursive move() method, though I can't find a logical error in it so I'd just be thrashing around in it more, probably making things worse rather than better without having a rhyme or reason.

Is there a trick to recovering multiple integer values from recursive calls in a for loop? It works fine with both my minimax and negamax implementations, but alpha-beta pruning seems to produce some strange results.

@Override public GameState move(GameState state) { int alpha = -INFINITY; int beta = INFINITY; int bestScore = -Integer.MAX_VALUE; GameTreeNode gameTreeRoot = new GameTreeNode(state); GameState bestMove = null; for(GameTreeNode child: gameTreeRoot.getChildren()) { if(bestMove == null) { bestMove = child.getState(); } alpha = Math.max(alpha, miniMax(child, plyDepth - 1, alpha, beta)); if(alpha > bestScore) { bestMove = child.getState(); bestScore = alpha; } } return bestMove; } private int miniMax(GameTreeNode currentNode, int depth, int alpha, int beta) { if(depth <= 0 || terminalNode(currentNode.getState())) { return getHeuristic(currentNode.getState()); } if(currentNode.getState().getCurrentPlayer().equals(selfColor)) { for(GameTreeNode child: currentNode.getChildren()) { alpha = Math.max(alpha, miniMax(child, depth - 1, alpha, beta)); if(alpha >= beta) { return beta; } } return alpha; } else { for(GameTreeNode child: currentNode.getChildren()) { beta = Math.min(beta, miniMax(child, depth - 1, alpha, beta)); if(alpha >= beta) { return alpha; } } return beta; } } //Checks to see if the node is terminal private boolean terminalNode(GameState state) { if(state.getStatus().equals(win) || state.getStatus().equals(lose) || state.getStatus().equals(draw)) { return true; } else { return false; } }

by (108k points)

Your alpha-beta pruning seems to produce some strange results because your minimax algorithm returns a random move from among the equal best moves and your alpha-beta pruning algorithm only returns the first best move (your implementation can't find equal moves). So picking a random move from among the best moves is better than just picking the first one in this case.

Coming back to your question, yes you can recover multiple integer values from recursive calls as in Java you would need to pass an object into the recursive function call, then modify the contents of that object. After the function returns you will be able to access the modified values.

Eg.

class ToBeReturned

int returnValue1;

int returnValue2;

int returnValue3;

}

The following code fixes the return values and maximizes pruning:

private int miniMax(GameTreeNode currentNode, int depth, int alpha, int beta)

if (depth <= 0 || terminalNode(currentNode.getState()))

return getHeuristic(currentNode.getState());

if (currentNode.getState().getCurrentPlayer().equals(selfColor)) {

int currentAlpha = -INFINITY;

for (GameTreeNode child : currentNode.getChildren())

currentAlpha = Math.max(currentAlpha, miniMax(child, depth - 1, alpha, beta));

alpha = Math.max(alpha, currentAlpha);

if (alpha >= beta)

return alpha;

} }

return currentAlpha;

int currentBeta = INFINITY;

for(GameTreeNode child : currentNode.getChildren())

{

currentBeta = Math.min(currentBeta, miniMax(child, depth - 1, alpha, beta));

beta = Math.min(beta, currentBeta);

if (beta <= alpha)

return beta;

} }

return currentBeta;

}

Interested in learning Artificial Intelligence? Learn more from this Artificial Intelligence Online Course