Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Minimum Bipartite Groups

  • Difficulty Level : Expert
  • Last Updated : 13 Aug, 2021

Given Adjacency List representation of graph of N vertices from 1 to N, the task is to count the minimum bipartite groups of the given graph.

Examples: 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: N = 5 
Below is the given graph with number of nodes is 5: 
 



Output:
Explanation: 
Possible groups satisfying the Bipartite property: [2, 5], [1, 3], [4] 
Below is the number of bipartite groups can be formed: 
 

Approach: 
The idea is to find the maximum height of all the Connected Components in the given graph of N nodes to find the minimum bipartite groups. Below are the steps: 

  1. For all the non-visited vertex in the given graph, find the height of the current Connected Components starting from the current vertex.
  2. Start DFS Traversal to find the height of all the Connected Components.
  3. The maximum of the heights calculated for all the Connected Components gives the minimum bipartite groups required.

Below is the implementation of the above approach: 

C++




#include <bits/stdc++.h>
using namespace std;
 
// Function to find the height sizeof
// the current component with vertex s
int height(int s, vector<int> adj[],
           int* visited)
{
    // Visit the current Node
    visited[s] = 1;
    int h = 0;
 
    // Call DFS recursively to find the
    // maximum height of current CC
    for (auto& child : adj[s]) {
 
        // If the node is not visited
        // then the height recursively
        // for next element
        if (visited[child] == 0) {
            h = max(h, 1 + height(child, adj,
                                  visited));
        }
    }
    return h;
}
 
// Function to find the minimum Groups
int minimumGroups(vector<int> adj[], int N)
{
    // Initialise with visited array
    int visited[N + 1] = { 0 };
 
    // To find the minimum groups
    int groups = INT_MIN;
 
    // Traverse all the non visited Node
    // and calculate the height of the
    // tree with current node as a head
    for (int i = 1; i <= N; i++) {
 
        // If the current is not visited
        // therefore, we get another CC
        if (visited[i] == 0) {
            int comHeight;
            comHeight = height(i, adj, visited);
            groups = max(groups, comHeight);
        }
    }
 
    // Return the minimum bipartite matching
    return groups;
}
 
// Function that adds the current edges
// in the given graph
void addEdge(vector<int> adj[], int u, int v)
{
    adj[u].push_back(v);
    adj[v].push_back(u);
}
 
// Drivers Code
int main()
{
    int N = 5;
 
    // Adjacency List
    vector<int> adj[N + 1];
 
    // Adding edges to List
    addEdge(adj, 1, 2);
    addEdge(adj, 3, 2);
    addEdge(adj, 4, 3);
 
    cout << minimumGroups(adj, N);
}

Java




import java.util.*;
 
class GFG{
  
// Function to find the height sizeof
// the current component with vertex s
static int height(int s, Vector<Integer> adj[],
           int []visited)
{
    // Visit the current Node
    visited[s] = 1;
    int h = 0;
  
    // Call DFS recursively to find the
    // maximum height of current CC
    for (int  child : adj[s]) {
  
        // If the node is not visited
        // then the height recursively
        // for next element
        if (visited[child] == 0) {
            h = Math.max(h, 1 + height(child, adj,
                                  visited));
        }
    }
    return h;
}
  
// Function to find the minimum Groups
static int minimumGroups(Vector<Integer> adj[], int N)
{
    // Initialise with visited array
    int []visited= new int[N + 1];
  
    // To find the minimum groups
    int groups = Integer.MIN_VALUE;
  
    // Traverse all the non visited Node
    // and calculate the height of the
    // tree with current node as a head
    for (int i = 1; i <= N; i++) {
  
        // If the current is not visited
        // therefore, we get another CC
        if (visited[i] == 0) {
            int comHeight;
            comHeight = height(i, adj, visited);
            groups = Math.max(groups, comHeight);
        }
    }
  
    // Return the minimum bipartite matching
    return groups;
}
  
// Function that adds the current edges
// in the given graph
static void addEdge(Vector<Integer> adj[], int u, int v)
{
    adj[u].add(v);
    adj[v].add(u);
}
  
// Drivers Code
public static void main(String[] args)
{
    int N = 5;
  
    // Adjacency List
    Vector<Integer> []adj = new Vector[N + 1];
    for (int i = 0 ; i < N + 1; i++)
        adj[i] = new Vector<Integer>();
     
    // Adding edges to List
    addEdge(adj, 1, 2);
    addEdge(adj, 3, 2);
    addEdge(adj, 4, 3);
  
    System.out.print(minimumGroups(adj, N));
}
}
 
// This code is contributed by 29AjayKumar

Python3




import sys
 
# Function to find the height sizeof
# the current component with vertex s
def height(s, adj, visited):
 
    # Visit the current Node
    visited[s] = 1
    h = 0
  
    # Call DFS recursively to find the
    # maximum height of current CC
    for child in adj[s]:
  
        # If the node is not visited
        # then the height recursively
        # for next element
        if (visited[child] == 0):
            h = max(h, 1 + height(child, adj,
                                  visited))
     
    return h
 
# Function to find the minimum Groups
def minimumGroups(adj, N):
 
    # Initialise with visited array
    visited = [0 for i in range(N + 1)]
  
    # To find the minimum groups
    groups = -sys.maxsize
  
    # Traverse all the non visited Node
    # and calculate the height of the
    # tree with current node as a head
    for i in range(1, N + 1):
  
        # If the current is not visited
        # therefore, we get another CC
        if (visited[i] == 0):
            comHeight = height(i, adj, visited)
            groups = max(groups, comHeight)
         
    # Return the minimum bipartite matching
    return groups
 
# Function that adds the current edges
# in the given graph
def addEdge(adj, u, v):
     
    adj[u].append(v)
    adj[v].append(u)
 
# Driver code   
if __name__=="__main__":
     
    N = 5
  
    # Adjacency List
    adj = [[] for i in range(N + 1)]
  
    # Adding edges to List
    addEdge(adj, 1, 2)
    addEdge(adj, 3, 2)
    addEdge(adj, 4, 3)
  
    print(minimumGroups(adj, N))
 
# This code is contributed by rutvik_56

C#




using System;
using System.Collections.Generic;
 
class GFG{
   
// Function to find the height sizeof
// the current component with vertex s
static int height(int s, List<int> []adj,
           int []visited)
{
    // Visit the current Node
    visited[s] = 1;
    int h = 0;
   
    // Call DFS recursively to find the
    // maximum height of current CC
    foreach (int  child in adj[s]) {
   
        // If the node is not visited
        // then the height recursively
        // for next element
        if (visited[child] == 0) {
            h = Math.Max(h, 1 + height(child, adj,
                                  visited));
        }
    }
    return h;
}
   
// Function to find the minimum Groups
static int minimumGroups(List<int> []adj, int N)
{
    // Initialise with visited array
    int []visited= new int[N + 1];
   
    // To find the minimum groups
    int groups = int.MinValue;
   
    // Traverse all the non visited Node
    // and calculate the height of the
    // tree with current node as a head
    for (int i = 1; i <= N; i++) {
   
        // If the current is not visited
        // therefore, we get another CC
        if (visited[i] == 0) {
            int comHeight;
            comHeight = height(i, adj, visited);
            groups = Math.Max(groups, comHeight);
        }
    }
   
    // Return the minimum bipartite matching
    return groups;
}
   
// Function that adds the current edges
// in the given graph
static void addEdge(List<int> []adj, int u, int v)
{
    adj[u].Add(v);
    adj[v].Add(u);
}
   
// Drivers Code
public static void Main(String[] args)
{
    int N = 5;
   
    // Adjacency List
    List<int> []adj = new List<int>[N + 1];
    for (int i = 0 ; i < N + 1; i++)
        adj[i] = new List<int>();
      
    // Adding edges to List
    addEdge(adj, 1, 2);
    addEdge(adj, 3, 2);
    addEdge(adj, 4, 3);
   
    Console.Write(minimumGroups(adj, N));
}
}
  
// This code is contributed by Rajput-Ji

Javascript




<script>
 
 
// Function to find the height sizeof
// the current component with vertex s
function height(s, adj, visited)
{
    // Visit the current Node
    visited[s] = 1;
    var h = 0;
 
    // Call DFS recursively to find the
    // maximum height of current CC
    adj[s].forEach(child => {
         
 
        // If the node is not visited
        // then the height recursively
        // for next element
        if (visited[child] == 0) {
            h = Math.max(h, 1 + height(child, adj,
                                  visited));
        }
    });
    return h;
}
 
// Function to find the minimum Groups
function minimumGroups(adj, N)
{
    // Initialise with visited array
    var visited = Array(N+1).fill(0);
 
    // To find the minimum groups
    var groups = -1000000000;
 
    // Traverse all the non visited Node
    // and calculate the height of the
    // tree with current node as a head
    for (var i = 1; i <= N; i++) {
 
        // If the current is not visited
        // therefore, we get another CC
        if (visited[i] == 0) {
            var comHeight;
            comHeight = height(i, adj, visited);
            groups = Math.max(groups, comHeight);
        }
    }
 
    // Return the minimum bipartite matching
    return groups;
}
 
// Function that adds the current edges
// in the given graph
function addEdge(adj, u, v)
{
    adj[u].push(v);
    adj[v].push(u);
}
 
// Drivers Code
var N = 5;
 
// Adjacency List
var adj = Array.from(Array(N+1), ()=>Array())
 
// Adding edges to List
addEdge(adj, 1, 2);
addEdge(adj, 3, 2);
addEdge(adj, 4, 3);
 
document.write( minimumGroups(adj, N));
 
 
 
</script>
Output: 
3

 

Time Complexity: O(V+E), where V is the number of vertices and E is the set of edges.
Auxiliary Space: O(V). 




My Personal Notes arrow_drop_up
Recommended Articles
Page :