Merge pull request #3 from rvguradiya/add-dodgeball_team_partitioning

Add solution for bipartite graph problem: Dodgeball team partitioning

Author: umathomprakash09

problems/general/dodgeball_team_partitioning.md

@@ -0,0 +1,31 @@
+This problem was asked by **Twitter**.
+
+A teacher must divide a class of students into two teams to play dodgeball. Unfortunately, not all the kids get along, and several refuse to be put on the same team as that of their enemies.
+
+Given an adjacency list of students and their enemies, write an algorithm that finds a satisfactory pair of teams, or returns False if none exists.
+
+For example, given the following enemy graph you should return the teams `{0, 1, 4, 5}` and `{2, 3}`.<br>
+
+```javascript
+students = {
+  0: [3],
+  1: [2],
+  2: [1, 4],
+  3: [0, 4, 5],
+  4: [2, 3],
+  5: [3],
+};
+```
+
+On the other hand, given the input below, you should return False.
+
+```javascript
+students = {
+  0: [3],
+  1: [2],
+  2: [1, 3, 4],
+  3: [0, 2, 4, 5],
+  4: [2, 3],
+  5: [3],
+};
+```

solutions/general/dodgeball_team_partitioning/Approach.java

@@ -0,0 +1,88 @@
+import java.util.*;
+
+public class Approach {
+
+    // Function to determine if the graph is bipartite
+    public static boolean isBipartite(Map<Integer, List<Integer>> students) {
+        int n = students.size(); // Number of students (vertices)
+        int[] color = new int[n]; // 0 means uncolored, 1 for team A, -1 for team B
+
+        // Iterate over each student
+        for (int student = 0; student < n; student++) {
+            if (color[student] == 0) { // If the student is uncolored, start BFS
+                if (!bfs(student, students, color)) {
+                    return false; // If BFS fails, the graph is not bipartite
+                }
+            }
+        }
+
+        // Print the two teams if bipartite
+        List<Integer> team1 = new ArrayList<>();
+        List<Integer> team2 = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            if (color[i] == 1) {
+                team1.add(i);
+            } else if (color[i] == -1) {
+                team2.add(i);
+            }
+        }
+        System.out.println("Team 1: " + team1);
+        System.out.println("Team 2: " + team2);
+        return true;
+    }
+
+    // BFS to color the graph
+    private static boolean bfs(int start, Map<Integer, List<Integer>> students, int[] color) {
+        Queue<Integer> queue = new LinkedList<>();
+        queue.add(start);
+        color[start] = 1; // Start by assigning the student to team A (1)
+
+        while (!queue.isEmpty()) {
+            int currentStudent = queue.poll();
+
+            // Traverse all the enemies of the current student
+            for (int enemy : students.get(currentStudent)) {
+                if (color[enemy] == 0) { // If the enemy is uncolored
+                    color[enemy] = -color[currentStudent]; // Assign opposite team
+                    queue.add(enemy);
+                } else if (color[enemy] == color[currentStudent]) {
+                    // If an enemy has the same color, the graph is not bipartite
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        // Example 1: Bipartite graph, should return two teams
+        Map<Integer, List<Integer>> students1 = new HashMap<>();
+        students1.put(0, Arrays.asList(3));
+        students1.put(1, Arrays.asList(2));
+        students1.put(2, Arrays.asList(1, 4));
+        students1.put(3, Arrays.asList(0, 4, 5));
+        students1.put(4, Arrays.asList(2, 3));
+        students1.put(5, Arrays.asList(3));
+
+        // Example 2: Not bipartite, should return false
+        Map<Integer, List<Integer>> students2 = new HashMap<>();
+        students2.put(0, Arrays.asList(3));
+        students2.put(1, Arrays.asList(2));
+        students2.put(2, Arrays.asList(1, 3, 4));
+        students2.put(3, Arrays.asList(0, 2, 4, 5));
+        students2.put(4, Arrays.asList(2, 3));
+        students2.put(5, Arrays.asList(3));
+
+        // Test Case 1: Bipartite, should print two teams
+        System.out.println("Test Case 1 Result:");
+        if (!isBipartite(students1)) {
+            System.out.println("Impossible to divide into two teams.");
+        }
+
+        // Test Case 2: Not bipartite, should return false
+        System.out.println("\nTest Case 2 Result:");
+        if (!isBipartite(students2)) {
+            System.out.println("Impossible to divide into two teams.");
+        }
+    }
+}

solutions/general/dodgeball_team_partitioning/approach.js

@@ -0,0 +1,73 @@
+function isBipartite(students) {
+  const n = Object.keys(students).length; // Number of students (vertices)
+  const color = Array(n).fill(0); // 0 means uncolored, 1 for team A, -1 for team B
+
+  // Helper function to perform BFS
+  const bfs = (student) => {
+    const queue = [student];
+    color[student] = 1; // Start coloring the first student with team A (1)
+
+    while (queue.length > 0) {
+      const currentStudent = queue.shift();
+
+      // Traverse all enemies of the current student
+      for (const enemy of students[currentStudent]) {
+        if (color[enemy] === 0) {
+          // If enemy is not yet colored
+          color[enemy] = -color[currentStudent]; // Assign opposite team
+          queue.push(enemy);
+        } else if (color[enemy] === color[currentStudent]) {
+          // If enemy has the same color as the current student, it's not bipartite
+          return false;
+        }
+      }
+    }
+    return true;
+  };
+
+  // Try to color each component of the graph
+  for (let student = 0; student < n; student++) {
+    if (color[student] === 0) {
+      // If student is uncolored
+      if (!bfs(student)) {
+        return false; // If one component is not bipartite, return false
+      }
+    }
+  }
+
+  // Separate students into two teams based on their color
+  const team1 = [];
+  const team2 = [];
+  for (let i = 0; i < n; i++) {
+    if (color[i] === 1) {
+      team1.push(i);
+    } else if (color[i] === -1) {
+      team2.push(i);
+    }
+  }
+
+  return [team1, team2]; // Return the two teams
+}
+
+// Example 1: Should return two teams
+const students1 = {
+  0: [3],
+  1: [2],
+  2: [1, 4],
+  3: [0, 4, 5],
+  4: [2, 3],
+  5: [3],
+};
+
+// Example 2: Should return false
+const students2 = {
+  0: [3],
+  1: [2],
+  2: [1, 3, 4],
+  3: [0, 2, 4, 5],
+  4: [2, 3],
+  5: [3],
+};
+
+console.log(isBipartite(students1)); // Output: [[0, 1, 4, 5], [2, 3]]
+console.log(isBipartite(students2)); // Output: false

solutions/general/dodgeball_team_partitioning/approach.py

@@ -0,0 +1,58 @@
+from collections import deque
+
+def is_bipartite(students):
+    # Number of students is the number of keys in the students dictionary
+    n = len(students)
+    
+    # Colors array to store team assignment (0 for uncolored, 1 for team A, -1 for team B)
+    color = [0] * n
+    
+    # Perform BFS for each uncolored student
+    for student in range(n):
+        if color[student] == 0:  # If the student is not yet colored
+            queue = deque([student])
+            color[student] = 1  # Assign the student to team 1
+            
+            # BFS traversal
+            while queue:
+                curr_student = queue.popleft()
+                
+                # Traverse all the enemies of the current student
+                for enemy in students[curr_student]:
+                    if color[enemy] == 0:  # If the enemy is not colored
+                        # Assign the enemy the opposite team
+                        color[enemy] = -color[curr_student]
+                        queue.append(enemy)
+                    elif color[enemy] == color[curr_student]:  # Conflict found
+                        return False
+    
+    # Separate students into two teams based on their color
+    team1 = [i for i in range(n) if color[i] == 1]
+    team2 = [i for i in range(n) if color[i] == -1]
+    
+    return (team1, team2)
+
+# Example usage:
+
+# Example 1: Should return two teams
+students1 = {
+    0: [3],
+    1: [2],
+    2: [1, 4],
+    3: [0, 4, 5],
+    4: [2, 3],
+    5: [3]
+}
+
+# Example 2: Should return False
+students2 = {
+    0: [3],
+    1: [2],
+    2: [1, 3, 4],
+    3: [0, 2, 4, 5],
+    4: [2, 3],
+    5: [3]
+}
+
+print(is_bipartite(students1))  # Output: ([0, 1, 4, 5], [2, 3])
+print(is_bipartite(students2))  # Output: False

solutions/general/three_sum_to_k/Approach.java

@@ -1,27 +1,24 @@
-
-import javax.sound.midi.SysexMessage;
-
-
 public class Approach {
 
-    public static boolean  isHaveSum(int []arr,int k,int sum,int i){
-        if (sum == 0) {
-            return true;
-          } else if (i == arr.length || k == 0 || sum < 0) {
-            return false;
-          }
-
-          if (isHaveSum(arr, k - 1, sum - arr[i], i + 1) == true) {
-            return true;
-          } else {
-            return isHaveSum(arr, k, sum, i + 1);
-          }
+  public static boolean isHaveSum(int[] arr, int k, int sum, int i) {
+    if (sum == 0) {
+      return true;
+    } else if (i == arr.length || k == 0 || sum < 0) {
+      return false;
     }
-    public static void main(String[] args) {
-        int []arr = {20,303,3,4,25};
-        int k =3;
-        int sum = 49;
 
-        System.out.println(isHaveSum(arr, k, sum, 0));
+    if (isHaveSum(arr, k - 1, sum - arr[i], i + 1) == true) {
+      return true;
+    } else {
+      return isHaveSum(arr, k, sum, i + 1);
     }
+  }
+
+  public static void main(String[] args) {
+    int[] arr = { 20, 303, 3, 4, 25 };
+    int k = 3;
+    int sum = 49;
+
+    System.out.println(isHaveSum(arr, k, sum, 0));
+  }
 }