diff --git a/DIRECTORY.md b/DIRECTORY.md index d0c62e600799..cfc8841fbcbe 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -1010,6 +1010,7 @@ * [JumpSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/JumpSearchTest.java) * [KMPSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/KMPSearchTest.java) * [LinearSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/LinearSearchTest.java) + * [MonteCarloTreeSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/MonteCarloTreeSearchTest.java) * [OrderAgnosticBinarySearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/OrderAgnosticBinarySearchTest.java) * [PerfectBinarySearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/PerfectBinarySearchTest.java) * [QuickSelectTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/QuickSelectTest.java) diff --git a/src/main/java/com/thealgorithms/searches/MonteCarloTreeSearch.java b/src/main/java/com/thealgorithms/searches/MonteCarloTreeSearch.java index 268c33cef610..aa74398b708b 100644 --- a/src/main/java/com/thealgorithms/searches/MonteCarloTreeSearch.java +++ b/src/main/java/com/thealgorithms/searches/MonteCarloTreeSearch.java @@ -39,12 +39,6 @@ public Node(Node parent, boolean isPlayersTurn) { static final int WIN_SCORE = 10; static final int TIME_LIMIT = 500; // Time the algorithm will be running for (in milliseconds). - public static void main(String[] args) { - MonteCarloTreeSearch mcts = new MonteCarloTreeSearch(); - - mcts.monteCarloTreeSearch(mcts.new Node(null, true)); - } - /** * Explores a game tree using Monte Carlo Tree Search (MCTS) and returns the * most promising node. diff --git a/src/test/java/com/thealgorithms/searches/MonteCarloTreeSearchTest.java b/src/test/java/com/thealgorithms/searches/MonteCarloTreeSearchTest.java new file mode 100644 index 000000000000..69c958f67a40 --- /dev/null +++ b/src/test/java/com/thealgorithms/searches/MonteCarloTreeSearchTest.java @@ -0,0 +1,126 @@ +package com.thealgorithms.searches; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.junit.jupiter.api.Test; + +class MonteCarloTreeSearchTest { + + /** + * Test the creation of a node and its initial state. + */ + @Test + void testNodeCreation() { + MonteCarloTreeSearch.Node node = new MonteCarloTreeSearch().new Node(null, true); + assertNotNull(node, "Node should be created"); + assertTrue(node.childNodes.isEmpty(), "Child nodes should be empty upon creation"); + assertTrue(node.isPlayersTurn, "Initial turn should be player's turn"); + assertEquals(0, node.score, "Initial score should be zero"); + assertEquals(0, node.visitCount, "Initial visit count should be zero"); + } + + /** + * Test adding child nodes to a parent node. + */ + @Test + void testAddChildNodes() { + MonteCarloTreeSearch mcts = new MonteCarloTreeSearch(); + MonteCarloTreeSearch.Node parentNode = mcts.new Node(null, true); + + mcts.addChildNodes(parentNode, 5); + + assertEquals(5, parentNode.childNodes.size(), "Parent should have 5 child nodes"); + for (MonteCarloTreeSearch.Node child : parentNode.childNodes) { + assertFalse(child.isPlayersTurn, "Child node should not be player's turn"); + assertEquals(0, child.visitCount, "Child node visit count should be zero"); + } + } + + /** + * Test the UCT selection of a promising node. + */ + @Test + void testGetPromisingNode() { + MonteCarloTreeSearch mcts = new MonteCarloTreeSearch(); + MonteCarloTreeSearch.Node parentNode = mcts.new Node(null, true); + + // Create child nodes with different visit counts and scores + for (int i = 0; i < 3; i++) { + MonteCarloTreeSearch.Node child = mcts.new Node(parentNode, false); + child.visitCount = i + 1; + child.score = i * 2; + parentNode.childNodes.add(child); + } + + // Get promising node + MonteCarloTreeSearch.Node promisingNode = mcts.getPromisingNode(parentNode); + + // The child with the highest UCT value should be chosen. + assertNotNull(promisingNode, "Promising node should not be null"); + assertEquals(0, parentNode.childNodes.indexOf(promisingNode), "The first child should be the most promising"); + } + + /** + * Test simulation of random play and backpropagation. + */ + @Test + void testSimulateRandomPlay() { + MonteCarloTreeSearch mcts = new MonteCarloTreeSearch(); + MonteCarloTreeSearch.Node node = mcts.new Node(null, true); + node.visitCount = 10; // Simulating existing visits + + // Simulate random play + mcts.simulateRandomPlay(node); + + // Check visit count after simulation + assertEquals(11, node.visitCount, "Visit count should increase after simulation"); + + // Check if score is updated correctly + assertTrue(node.score >= 0 && node.score <= MonteCarloTreeSearch.WIN_SCORE, "Score should be between 0 and WIN_SCORE"); + } + + /** + * Test retrieving the winning node based on scores. + */ + @Test + void testGetWinnerNode() { + MonteCarloTreeSearch mcts = new MonteCarloTreeSearch(); + MonteCarloTreeSearch.Node parentNode = mcts.new Node(null, true); + + // Create child nodes with varying scores + MonteCarloTreeSearch.Node winningNode = mcts.new Node(parentNode, false); + winningNode.score = 10; // Highest score + parentNode.childNodes.add(winningNode); + + MonteCarloTreeSearch.Node losingNode = mcts.new Node(parentNode, false); + losingNode.score = 5; + parentNode.childNodes.add(losingNode); + + MonteCarloTreeSearch.Node anotherLosingNode = mcts.new Node(parentNode, false); + anotherLosingNode.score = 3; + parentNode.childNodes.add(anotherLosingNode); + + // Get the winning node + MonteCarloTreeSearch.Node winnerNode = mcts.getWinnerNode(parentNode); + + assertEquals(winningNode, winnerNode, "Winning node should have the highest score"); + } + + /** + * Test the full Monte Carlo Tree Search process. + */ + @Test + void testMonteCarloTreeSearch() { + MonteCarloTreeSearch mcts = new MonteCarloTreeSearch(); + MonteCarloTreeSearch.Node rootNode = mcts.new Node(null, true); + + // Execute MCTS and check the resulting node + MonteCarloTreeSearch.Node optimalNode = mcts.monteCarloTreeSearch(rootNode); + + assertNotNull(optimalNode, "MCTS should return a non-null optimal node"); + assertTrue(rootNode.childNodes.contains(optimalNode), "Optimal node should be a child of the root"); + } +}