algorithm/Java
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Java.git synced 2025-07-08 02:04:31 +08:00
Code Issues Packages Projects Releases Wiki Activity

Refactor BipartiteGraphDFS.java, add Junit tests (#5606)

Browse Source 
* Refactor `BipartiteGraphDFS.java`, add Junit tests

* Update directory

* Fix

* Add suggested changes

* Update BipartiteGraphDFS.java

---------

Co-authored-by: Hardvan <Hardvan@users.noreply.github.com>
Co-authored-by: Alex Klymenko <alexanderklmn@gmail.com>
This commit is contained in:
Hardik Pawar
2024-10-07 17:01:13 +05:30
committed by GitHub
parent 2001a097e2
commit 387707ffe5
3 changed files with 114 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
src/main/java/com/thealgorithms/datastructures/graphs/BipartiteGraphDFS.java
View File

@ -1,23 +1,49 @@
package com.thealgorithms.datastructures.graphs;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
/**
* Given an adjacency list of a graph adj of V no. of vertices having 0 based
* index. Check whether the graph is bipartite or not.
* 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.
*
* Input : {{0, 1, 0, 1}, {1, 0, 1, 0}, {0, 1, 0, 1}, {1, 0, 1, 0}}
* 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.
*
* Output : YES
* Example:
* 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() {
}
/**
* 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 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) {
color[node] = 1;
@ -35,11 +61,16 @@ public final class BipartiteGraphDFS {
return true;
}
/**
* Method to check if the graph is bipartite.
*
* @param v Number of vertices in the graph
* @param adj Adjacency list of the graph
* @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++) {
if (color[i] == -1) {
if (!bipartite(v, adj, color, i)) {
@ -49,33 +80,4 @@ public final class BipartiteGraphDFS {
}
return true;
}
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");
}
}
}
}