From 2f9f75a3a70a11f3321396fd4a65c7331b50574c Mon Sep 17 00:00:00 2001 From: "Vignesh.S" <128959041+coffee-loves-code-2003@users.noreply.github.com> Date: Wed, 23 Oct 2024 11:14:02 +0530 Subject: [PATCH] Add StronglyConnectedComponentOptimized (#5825) --- .../StronglyConnectedComponentOptimized.java | 84 +++++++++++++++++++ ...ronglyConnectedComponentOptimizedTest.java | 78 +++++++++++++++++ 2 files changed, 162 insertions(+) create mode 100644 src/main/java/com/thealgorithms/graph/StronglyConnectedComponentOptimized.java create mode 100644 src/test/java/com/thealgorithms/graph/StronglyConnectedComponentOptimizedTest.java diff --git a/src/main/java/com/thealgorithms/graph/StronglyConnectedComponentOptimized.java b/src/main/java/com/thealgorithms/graph/StronglyConnectedComponentOptimized.java new file mode 100644 index 000000000..87d4e89d2 --- /dev/null +++ b/src/main/java/com/thealgorithms/graph/StronglyConnectedComponentOptimized.java @@ -0,0 +1,84 @@ +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Stack; + +/** + * Finds the strongly connected components in a directed graph. + * + * @param adjList The adjacency list representation of the graph. + * @param n The number of nodes in the graph. + * @return The number of strongly connected components. + */ +public class StronglyConnectedComponentOptimized { + + public void btrack(HashMap> adjList, int[] visited, Stack dfsCallsNodes, int currentNode) { + visited[currentNode] = 1; + List neighbors = adjList.get(currentNode); + // Check for null before iterating + if (neighbors != null) { + for (int neighbor : neighbors) { + if (visited[neighbor] == -1) { + btrack(adjList, visited, dfsCallsNodes, neighbor); + } + } + } + dfsCallsNodes.add(currentNode); + } + + public void btrack2(HashMap> adjRevList, int[] visited, int currentNode, List newScc) { + visited[currentNode] = 1; + newScc.add(currentNode); + List neighbors = adjRevList.get(currentNode); + // Check for null before iterating + if (neighbors != null) { + for (int neighbor : neighbors) { + if (visited[neighbor] == -1) { + btrack2(adjRevList, visited, neighbor, newScc); + } + } + } + } + + public int getOutput(HashMap> adjList, int n) { + int[] visited = new int[n]; + Arrays.fill(visited, -1); + Stack dfsCallsNodes = new Stack<>(); + + for (int i = 0; i < n; i++) { + if (visited[i] == -1) { + btrack(adjList, visited, dfsCallsNodes, i); + } + } + + HashMap> adjRevList = new HashMap<>(); + for (int i = 0; i < n; i++) { + adjRevList.put(i, new ArrayList<>()); + } + + for (int i = 0; i < n; i++) { + List neighbors = adjList.get(i); + // Check for null before iterating + if (neighbors != null) { + for (int neighbor : neighbors) { + adjRevList.get(neighbor).add(i); + } + } + } + + Arrays.fill(visited, -1); + int stronglyConnectedComponents = 0; + + while (!dfsCallsNodes.isEmpty()) { + int node = dfsCallsNodes.pop(); + if (visited[node] == -1) { + List newScc = new ArrayList<>(); + btrack2(adjRevList, visited, node, newScc); + stronglyConnectedComponents++; + } + } + + return stronglyConnectedComponents; + } +} diff --git a/src/test/java/com/thealgorithms/graph/StronglyConnectedComponentOptimizedTest.java b/src/test/java/com/thealgorithms/graph/StronglyConnectedComponentOptimizedTest.java new file mode 100644 index 000000000..6f1c8a9d5 --- /dev/null +++ b/src/test/java/com/thealgorithms/graph/StronglyConnectedComponentOptimizedTest.java @@ -0,0 +1,78 @@ +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class StronglyConnectedComponentOptimizedTest { + + private StronglyConnectedComponentOptimized sccOptimized; + + @BeforeEach + public void setUp() { + sccOptimized = new StronglyConnectedComponentOptimized(); + } + + @Test + public void testSingleComponent() { + // Create a simple graph with 3 nodes, all forming one SCC + HashMap> adjList = new HashMap<>(); + adjList.put(0, new ArrayList<>(List.of(1))); + adjList.put(1, new ArrayList<>(List.of(2))); + adjList.put(2, new ArrayList<>(List.of(0))); + + int result = sccOptimized.getOutput(adjList, 3); + + // The entire graph is one strongly connected component + assertEquals(1, result, "There should be 1 strongly connected component."); + } + + @Test + public void testTwoComponents() { + // Create a graph with 4 nodes and two SCCs: {0, 1, 2} and {3} + HashMap> adjList = new HashMap<>(); + adjList.put(0, new ArrayList<>(List.of(1))); + adjList.put(1, new ArrayList<>(List.of(2))); + adjList.put(2, new ArrayList<>(List.of(0))); + adjList.put(3, new ArrayList<>()); + + int result = sccOptimized.getOutput(adjList, 4); + + // There are 2 SCCs: {0, 1, 2} and {3} + assertEquals(2, result, "There should be 2 strongly connected components."); + } + + @Test + public void testDisconnectedGraph() { + // Create a graph with 4 nodes that are all disconnected + HashMap> adjList = new HashMap<>(); + adjList.put(0, new ArrayList<>()); + adjList.put(1, new ArrayList<>()); + adjList.put(2, new ArrayList<>()); + adjList.put(3, new ArrayList<>()); + + int result = sccOptimized.getOutput(adjList, 4); + + // Each node is its own strongly connected component + assertEquals(4, result, "There should be 4 strongly connected components."); + } + + @Test + public void testComplexGraph() { + // Create a more complex graph with multiple SCCs + HashMap> adjList = new HashMap<>(); + adjList.put(0, new ArrayList<>(List.of(1))); + adjList.put(1, new ArrayList<>(List.of(2))); + adjList.put(2, new ArrayList<>(List.of(0, 3))); + adjList.put(3, new ArrayList<>(List.of(4))); + adjList.put(4, new ArrayList<>(List.of(5))); + adjList.put(5, new ArrayList<>(List.of(3))); + + int result = sccOptimized.getOutput(adjList, 6); + + // There are 2 SCCs: {0, 1, 2} and {3, 4, 5} + assertEquals(2, result, "There should be 2 strongly connected components."); + } +}