Add suggested changes

Author: Hardvan

src/main/java/com/thealgorithms/datastructures/graphs/BipartiteGraphDFS.java

@@ -7,13 +7,29 @@
 import java.util.Arrays;
 
 /**
- * This class provides a method to check if a given graph is bipartite using Depth-First Search (DFS).
- * A bipartite graph is a graph whose vertices can be divided into two disjoint sets such that no two graph vertices
- * within the same set are adjacent.
+ * This class provides a method to check if a given undirected graph is bipartite using Depth-First Search (DFS).
+ * A bipartite graph is a graph whose vertices can be divided into two disjoint sets such that no two vertices
+ * within the same set are adjacent. In other words, all edges must go between the two sets.
+ *
+ * The implementation leverages DFS to attempt to color the graph using two colors. If we can color the graph such
+ * that no two adjacent vertices have the same color, the graph is bipartite.
  *
  * Example:
- * Input : {{0, 1, 0, 1}, {1, 0, 1, 0}, {0, 1, 0, 1}, {1, 0, 1, 0}}
- * Output : YES
+ * Input (Adjacency Matrix):
+ * {{0, 1, 0, 1},
+ *  {1, 0, 1, 0},
+ *  {0, 1, 0, 1},
+ *  {1, 0, 1, 0}}
+ *
+ * Output: YES (This graph is bipartite)
+ *
+ * Input (Adjacency Matrix):
+ * {{0, 1, 1, 0},
+ *  {1, 0, 1, 0},
+ *  {1, 1, 0, 1},
+ *  {0, 0, 1, 0}}
+ *
+ * Output: NO (This graph is not bipartite)
  */
 public final class BipartiteGraphDFS {
     private BipartiteGraphDFS() {
@@ -22,11 +38,14 @@ private BipartiteGraphDFS() {
     /**
      * Helper method to perform DFS and check if the graph is bipartite.
      *
+     * During DFS traversal, this method attempts to color each vertex in such a way
+     * that no two adjacent vertices share the same color.
+     *
      * @param v     Number of vertices in the graph
-     * @param adj   Adjacency list of the graph
-     * @param color Array to store colors assigned to vertices
-     * @param node  Current node being processed
-     * @return      True if the graph is bipartite, otherwise false
+     * @param adj   Adjacency list of the graph where each index i contains a list of adjacent vertices
+     * @param color Array to store the color assigned to each vertex (-1 indicates uncolored)
+     * @param node  Current vertex being processed
+     * @return      True if the graph (or component of the graph) is bipartite, otherwise false
      */
     private static boolean bipartite(int v, ArrayList<ArrayList<Integer>> adj, int[] color, int node) {
         if (color[node] == -1) {
@@ -53,7 +72,6 @@ private static boolean bipartite(int v, ArrayList<ArrayList<Integer>> adj, int[]
      * @return    True if the graph is bipartite, otherwise false
      */
     public static boolean isBipartite(int v, ArrayList<ArrayList<Integer>> adj) {
-        // Code here
         int[] color = new int[v + 1];
         Arrays.fill(color, -1);
         for (int i = 0; i < v; i++) {
@@ -65,39 +83,4 @@ public static boolean isBipartite(int v, ArrayList<ArrayList<Integer>> adj) {
         }
         return true;
     }
-
-    /**
-     * Main method to read input and check if the graph is bipartite.
-     *
-     * @param args Command line arguments
-     * @throws IOException If an I/O error occurs
-     */
-    public static void main(String[] args) throws IOException {
-        BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
-        int t = Integer.parseInt(read.readLine().trim());
-        while (t-- > 0) {
-            String[] str1 = read.readLine().trim().split(" ");
-            int numVertices = Integer.parseInt(str1[0]);
-            int numEdges = Integer.parseInt(str1[1]);
-
-            ArrayList<ArrayList<Integer>> adj = new ArrayList<>();
-            for (int i = 0; i < numVertices; i++) {
-                adj.add(new ArrayList<>());
-            }
-            for (int i = 0; i < numEdges; i++) {
-                String[] str2 = read.readLine().trim().split(" ");
-                int vertexU = Integer.parseInt(str2[0]);
-                int vertexV = Integer.parseInt(str2[1]);
-                adj.get(vertexU).add(vertexV);
-                adj.get(vertexV).add(vertexU);
-            }
-
-            boolean ans = isBipartite(numVertices, adj);
-            if (ans) {
-                System.out.println("YES");
-            } else {
-                System.out.println("NO");
-            }
-        }
-    }
 }