Bipartite Graph in Python

In this tutorial, we will learn about bipartite graphs and the ways to check if a given graph is bipartite or not.

A bipartite graph is one whose vertices can be separated into two independent sets. Let the two sets be S1 and S2. The two sets will contain elements s1 and s2, where s1 and s2 are connected through an edge in the graph. Hence, the elements (s1, s2) are the edges connecting a vertex from the set S1 to the vertex of the second set s2. Also, the elements of a set cannot have an edge connecting each other.

A graph is called a bipartite graph if there is a way to give two colors to the vertices of the graph such that all the pairs of adjacent nodes have different colors.

A bipartite graph is possible if the graph coloring is possible using two colors such that vertices in a set are colored with the same color. Note that it is possible to color a cycle graph with an even cycle using two colors. For example, see the following graph.

It is not possible to color a cycle graph with an odd cycle using two colors.

Algorithm to check if a graph is Bipartite:

The simple way to check if the graph is bipartite or not is to give each node a color. We will have a palette of two colors, and we color each node with an alternative color. If we can color each node with no adjacent nodes having the same color, then the graph is bipartite; otherwise, it is not.

We will give the current vertex color and give the alternate color to each of its neighbors. This way, we will traverse each vertex and color the nodes. If, at any point, we find that the parent node and the adjacent node have the same color, we will stop the algorithm and print that the given graph is not bipartite.

Code

# Python program to find if the given graph is Bipartite or not using the BFS algorithm

# Defining a constructor class for the graph
class Graph():

  # Defining the method that will initialize the adjacency matrix of the graph
  def __init__(self, vertex):
    self.V = vertex
    self.matrix = [[0 for i in range(vertex)] for j in range(vertex)]

  # Defing a function that will use BFS traversal to traverse the given graph and will return True if the given graph is bipartite
  def checkBipartite(self, src):

    # We will create an array that will store the color of all the nodes of the graph.
    # Each index represents the ith vertex. Hence, we can access a vertex using indexing
    # Initially, each vertex will have the color -1.
    # We will give the source node color 0 to initiate the process.
    # During traversal, the rest of the colors will be updated. If two adjacent vertices have the same color, we will return False
    a = [-1] * self.V

    # Assigning the source node as color 0
    a[src] = 0

    # Initializing a queue and adding the source node to it
    q = []
    q.append(src)

    # Now, we will start the BFS traversal. The traversal will go on until the queue has elements
    while q:

      n = q.pop()

      # If the current node points to itself, we will return False
      if self.matrix[n][n] == 1:
        return False;

      # Traversing the elements that are adjacent to the current node
      for v in range(self.V):

        # If there is an edge between n and v and the color of v is not marked before, it is -1.
        if self.matrix[n][v] == 1 and a[v] == -1:

          # We will assign an alternate color of v to n
          a[v] = 1 - a[n]
          q.append(v)

        # Now, we will check if the end nodes of the current edge have the same colors. If yes, then we will return False
        elif self.matrix[n][v] == 1 and a[v] == a[n]:
          return False

    # If the traversal is completed without returning False, that means the graph is bipartite; hence, we will return True
    return True

# Creating a graph and passing it to the function
g = Graph(5)
g.matrix = [[0, 1, 1, 1, 0],
      [1, 0, 1, 1, 0],
      [1, 1, 0, 1, 1],
      [1, 1, 1, 0, 0],
      [0, 0, 1, 0, 0]
      ]

# Checking if the given graph is bipartite
if g.checkBipartite(0):
  print("The graph is a Bipartite graph")
else: print("The given graph is not a Bipartite graph")

Output

The given graph is not a Bipartite graph

Time Complexity: We are traversing through the elements of the adjacency matrix of size V * V. In the worst-case scenario, we will traverse each element of the matrix; hence, the time complexity will be O(V * V).

Space Complexity: We are creating a queue and an array to store the color of the vertices. Hence, the space complexity is O(V).

The algorithm we have created will only work for a Singly Connected graph. If the graph has multiple components, then only one component will be traversed. We need to modify the code so that it works for multiple components. We will start from source 0, and we know that the connected nodes will be visited. A graph with no edge is a Bipartite graph. This is because, in the bipartite graph, a node of a single set should not be connected to itself.

We will modify the code to handle these cases. The BFS traversal will be called for each component of the graph until all the nodes of the graph are visited.

Code

# Python program to tell if the given connected graph is bipartite or not

# Defining a constructor class for the graph
class Graph():

  # Defining the method that will initialize the adjacency matrix of the graph
  def __init__(self, vertex):
    self.V = vertex
    self.matrix = [[0 for i in range(vertex)] for j in range(vertex)]


  # Defining a function that will perform the BFS traversal on the nodes connected to the given source node
  # We will call this function for all the components of the graph
  def checkBipartite(self, src):

    # We will create an array that will store the color of all the nodes of the graph.
    # Each index represents the ith vertex. Hence, we can access a vertex using indexing
    # Initially, each vertex will have the color -1.
    # We will give the source node color 0 to initiate the process.
    # During traversal, the rest of the colors will be updated. If two adjacent vertices have the same color, we will return a False

    # Assigning the source node as color 0
    self.color[src] = 0

    # Initializing a queue and adding the source node to it
    q = []
    q.append(src)

    # Now, we will start the BFS traversal. The traversal will go on until the queue has elements
    while q:

      n = q.pop()

      # If the current node points to itself, we will return False
      if self.matrix[n][n] == 1:
        return False;

      # Traversing the elements that are adjacent to the current node
      for v in range(self.V):

        # If there is an edge between n and v and the color of v is not marked before, it is -1.
        if self.matrix[n][v] == 1 and self.color[v] == -1:

          # We will assign an alternate color of v to n
          self.color[v] = 1 - self.color[n]
          q.append(v)

        # Now, we will check if the end nodes of the current edge have the same colors. If yes, then we will return False
        elif self.matrix[n][v] == 1 and self.color[v] == self.color[n]:
          return False

    # If the traversal is completed without returning False, that means the graph is bipartite; hence, we will return True
    return True

  # This function will check if the complete graph is bipartite or not. For a complete graph to be bipartite, each component of the graph should be bipartite individually.
  def isBipartite(self):

    # Initializing the matrix that will store the color of the nodes
    self.color = [-1 for i in range(self.V)]
    for i in range(self.V):
      # If the node is not yet colored, we will call the BFS traversal function for this node to color to this node and all the adjacent nodes
      if self.color[i] == -1:
        if not self.checkBipartite(i):
          return False
    return True

# Creating a graph and passing it to the function
g = Graph(5)
g.matrix = [[0, 1, 1, 1, 0],
      [1, 0, 1, 1, 0],
      [1, 1, 0, 1, 1],
      [1, 1, 1, 0, 0],
      [0, 0, 1, 0, 0]
      ]

# Checking if the given graph is bipartite
if g.isBipartite():
  print("The graph is a Bipartite graph")
else: print("The given graph is not a Bipartite graph")

Output

The given graph is not a Bipartite graph

Time complexity: We are traversing the total number of vertices and edges. Hence, the time complexity is O(V + E).

Space Complexity: We have created an array to store the visited nodes. Hence, the space complexity is O(V).

In the above examples, the graph was represented by an adjacency matrix. What if an adjacency list represents the graph? Hence, now we will see the BFS traversal on the adjacency list. The time complexity of this algorithm will be O(V + E). This is a general algorithm that will work for both Singly connected and Multi-Connected graphs.

Code

# Python program to tell if the given graph in the form of an adjacency list is bipartite or not

# Defining a constructor class for the graph
class Graph:

  # Constructor to construct a graph with the given number of vertices
  def __init__(self, v):

    # Initializing the given number of vertices
    self.V = v

    # Creating a List to store the nodes of the graph
    self.adj_list = [[] for i in range(self.V)]

  # Defining the function to add an edge to the graph
  def Edge(self, u, v):
    # Since it is an undirected graph, u and v will be added to the neighborhood list of each other
    # Adding the vertex v to the neighbors' list of u
    self.adj_list[v].append(u)

    # Adding the vertex u to the neighbors' list of v
    self.adj_list[u].append(v)


  # Defing a function that will use BFS traversal to traverse the given graph and will return True if the given graph is bipartite
  def isBipartite(self):

    # Creating a vector to store the colors of the nodes. We will initialize the vector by giving the color -1 to each node
    # later, the nodes will be marked 0 and 1 alternatively.
    # If any two adjacent nodes have the same color values, the graph is not bipartite
    col = [-1] * self.V
   
    # Creating a queue to perform the BFS traversal.
    # This queue will store the node and the color of this node
    q = []
   
    # Creating a loop to traverse all the nodes to keep in check the connected components of the graph
    for src in range(self.V):
     
      # If the current node is not colored or not visited
      if (col[src] == -1):
       
        # putting the current source node in the queue and giving it the color 0
        q.append([src, 0])

        # Also marking the color in the col array
        col[src] = 0
       
       # Running a while loop until the queue is not empty
        while len(q) != 0:

          # Getting the current node n and its color c from the queue
          n, c = q.pop()
           
          # Running a for loop to traverse the nodes connected to the current node and adding those nodes to the queue
          for a in self.adj_list[n]:
           
            # If the current node is already colored, we will check if its color is the same as the color of the parent node
            if (col[a] == c):
              # if yes, then the graph is not bipartite
              return False
           
            # If the current node is not colored
            if (col[a] == -1):
             
              # We will give the current node the opposite color than the color of the parent node
              if c == 1:
                col[a] = 0
              else:
                col[a] = 1
              # Adding the node to the queue
              q.append([a, col[a]])
    
    # If all vertices of the graph are colored alternatively with 0 and 1, then the graph is bipartite. Hence, return True
    return True

# Creating a graph
g = Graph(9)
g.Edge(1, 2)
g.Edge(1, 5)
g.Edge(2, 3)
g.Edge(2, 1)
g.Edge(3, 2)
g.Edge(3, 4)
g.Edge(4, 3)
g.Edge(4, 8)
g.Edge(5, 1)
g.Edge(5, 6)
g.Edge(6, 7)
g.Edge(6, 5)
g.Edge(7, 6)
g.Edge(7, 8)
g.Edge(8, 7)
g.Edge(8, 2)

check = g.isBipartite()

if (check):
  print("The graph is a bipartite graph")
else:
  print("The graph is not a bipartite graph")

Output

The graph is a bipartite graph

Time Complexity: The time complexity of this approach is same as the previous algorithm, i.e., O(V * V).

Space Complexity: We have created an array to store the visited nodes. Hence, the space complexity is O(V).

Let us see how to check if the graph is bipartite or not if the adjacency list of the graph is given

Code

# Python program to tell if the given connected graph is bipartite or not

# Defining a constructor class for the graph
class Graph():

  # Defining the method that will initialize the adjacency matrix of the graph
  def __init__(self, vertex):
    self.V = vertex
    self.matrix = [[0 for i in range(vertex)] for j in range(vertex)]

  # Defining a function that will perform the BFS traversal on the nodes connected to the given source node
  # We will call this function for all the components of the graph
  def checkBipartite(self, src):

    # We will create an array that will store the color of all the nodes of the graph.
    # Each index represents the ith vertex. Hence, we can access a vertex using indexing
    # Initially, each vertex will have the color -1.
    # We will give the source node color 0 to initiate the process.
    # During traversal, the rest of the colors will be updated. If two adjacent vertices have the same color, we will return a False

    # Assigning the source node as color 0
    self.color[src] = 0

    # Initializing a queue and adding the source node to it
    q = []
    q.append(src)

    # Now, we will start the BFS traversal. The traversal will go on until the queue has elements
    while q:

      n = q.pop()

      # If the current node points to itself, we will return False
      if self.matrix[n][n] == 1:
        return False;

      # Traversing the elements that are adjacent to the current node
      for v in range(self.V):

        # If there is an edge between n and v and the color of v is not marked before hence is -1.
        if self.matrix[n][v] == 1 and self.color[v] == -1:

          # We will assign an alternate color of v to n
          self.color[v] = 1 - self.color[n]
          q.append(v)

        # Now, we will check if the end nodes of the current edge have the same colors. If yes, then we will return False
        elif self.matrix[n][v] == 1 and self.color[v] == self.color[n]:
          return False

    # If the traversal is completed without returning False, that means the graph is bipartite; hence, we will return True
    return True

Output

The graph is a bipartite graph

Time Complexity: If we traverse the graph given in the form of the adjacency list the time complexity reduces to O(V + E), here V is the number of vertices and E is the number of edges present in the graph.

Space Complexity: We have created an array to store the visited nodes. Hence, the space complexity is O(V).

Next TopicDetect-cycle-in-undirected-graph-in-python

← prev next →