java.lang.OutOfMemoryError en essayant de mettre en œuvre l'algorithme Minimax

Christos_gm:

Je mis en œuvre l'algorithme minimax pour une variante de tic tac toe sauvage en Java et je suis tombé sur un problème. J'ai une classe de nœud qui détient la grille de jeu et un ArrayList d'objets Node qui sont ses enfants et une méthode Minimax qui implémente l'algorithme récursive.

L'erreur que je reçois est:

Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
        at Grid.<init>(Grid.java:35)
        at MiniMax$Node.findChildren(MiniMax.java:27)
        at MiniMax.minimax(MiniMax.java:135)
        at MiniMax.minimax(MiniMax.java:126)
        at MiniMax.minimax(MiniMax.java:139)
        at MiniMax.minimax(MiniMax.java:126)
        at MiniMax.minimax(MiniMax.java:139)
        at MiniMax.minimax(MiniMax.java:126)
        at MiniMax.minimax(MiniMax.java:139)
        at MiniMax.nextMove(MiniMax.java:77)
        at ComputerPlayer.play(ComputerPlayer.java:12)
        at TicTacToe.main(TicTacToe.java:146)

Process finished with exit code 1

Je pense que le problème se produit en raison de la grande quantité d'enfants (nœuds au total: 2 ^ 8 * 8) qui sont créés récursive à chaque fois et stocké dans les ArrayLists.

Voici la classe Node:

 private static class Node
    {
        protected Grid grid;
        protected ArrayList<Node> children;

        public Node(Grid grid)
        {
            this.grid = grid;
            children = new ArrayList<>();
        }

        //Find all possible next moves
        public void findChildren()
        {
            char[][] board = grid.getGrid();
            for(int i = 0; i < board.length; i++)
            {
                for(int j = 0; j < board.length; j++)
                {
                    if(board[i][j] == ' ')
                    {
                        board[i][j] = 'X';
                        children.add(new Node(new Grid(board)));
                        board[i][j] = 'O';
                        children.add( new Node(new Grid(board)));
                        board[i][j] = ' ';
                    }
                }
            }
        }
    }

Voici la mise en œuvre Minimax:

private int minimax(Node state, int depth, boolean isMaximizer)
    {
        //If the game is in a terminal state or has reached the desired depth
        boolean someoneWon = state.grid.someoneHasWon();
        boolean isDraw =  state.grid.isDraw();
        if(someoneWon || isDraw || depth == 3)
        {
            return evaluateState(someoneWon, isDraw, !isMaximizer);//Evaluate the state
        }
        //MAX player's turn
        if(isMaximizer)
        {
            //Find maximum score of all possible state's scores
            int bestScore = Integer.MIN_VALUE;
            state.findChildren();
            for(int i = 0; i < state.children.size(); i++)
            {
                Node child = state.children.get(i);
                int score = minimax(child, depth + 1, false);
                bestScore = Math.max(bestScore, score);
            }
            return bestScore;
        }
        else//MIN player's turn
        {
            //Find minimum score of all possible move's scores
            int bestScore = Integer.MAX_VALUE;
            state.findChildren();
            for(int i = 0; i < state.children.size(); i++)
            {
                Node child = state.children.get(i);
                int score = minimax(child, depth + 1, true);
                bestScore = Math.min(bestScore, score);
            }
            return bestScore;
        }
    }

Tom Hawtin - tackline:

Au lieu de créer une liste de nœuds enfants, déplacer l'itération dans Node(ou équivalent Vous remarquerez que vous n'avez pas besoin de créer un nouveau conseil d' administration chaque fois -. Il suffit de remplacer l'état que vous avez changé après qu'il est terminé avec.