Add Graph Colouring algorithm with Backtracking

Author: AswinPKumar01

graphs/graph_colouring.py

@@ -7,39 +7,44 @@
 """
 
 
-def is_safe(graph: list[list[int]], color: list[int], v: int, c: int) -> bool:
+def is_safe(
+    graph: list[list[int]], color: list[int], vertex: int, color_choice: int
+) -> bool:
     """
-    Helper function to check if it is safe to color vertex `v` with color `c`.
+    Helper function to check if it is safe to color a vertex with a specific color.
 
     Parameters:
     graph (list[list[int]]): The adjacency matrix of the graph.
     color (list[int]): The list of colors assigned to each vertex.
-    v (int): The vertex to check.
-    c (int): The color to be assigned.
+    vertex (int): The vertex to check.
+    color_choice (int): The color to be assigned.
 
     Returns:
-    bool: True if it's safe to assign color `c` to vertex `v`, otherwise False.
+    bool: True if it's safe to assign the color, otherwise False.
 
     Example:
     >>> graph = [[0, 1, 1], [1, 0, 1], [1, 1, 0]]
     >>> color = [-1, -1, -1]
     >>> is_safe(graph, color, 0, 1)
     True
     """
-    return all(not (graph[v][i] == 1 and color[i] == c) for i in range(len(graph)))
+    return all(
+        not (graph[vertex][i] == 1 and color[i] == color_choice)
+        for i in range(len(graph))
+    )
 
 
 def graph_coloring_util(
-    graph: list[list[int]], m: int, color: list[int], v: int
+    graph: list[list[int]], num_colors: int, color: list[int], vertex: int
 ) -> bool:
     """
     Utility function that uses backtracking to solve the m-coloring problem.
 
     Parameters:
     graph (list[list[int]]): The adjacency matrix of the graph.
-    m (int): The maximum number of colors.
+    num_colors (int): The maximum number of colors.
     color (list[int]): The list of colors assigned to each vertex.
-    v (int): The current vertex to be colored.
+    vertex (int): The current vertex to be colored.
 
     Returns:
     bool: True if all vertices are successfully colored, otherwise False.
@@ -50,34 +55,34 @@ def graph_coloring_util(
     >>> graph_coloring_util(graph, 3, color, 0)
     True
     """
-    if v == len(graph):
+    if vertex == len(graph):
         return True
 
-    for c in range(1, m + 1):
-        if is_safe(graph, color, v, c):
-            color[v] = c
-            if graph_coloring_util(graph, m, color, v + 1):
+    for color_choice in range(1, num_colors + 1):
+        if is_safe(graph, color, vertex, color_choice):
+            color[vertex] = color_choice
+            if graph_coloring_util(graph, num_colors, color, vertex + 1):
                 return True
-            color[v] = -1  # Backtrack
+            color[vertex] = -1  # Backtrack
 
     return False
 
 
-def graph_coloring(graph: list[list[int]], m: int) -> bool:
+def graph_coloring(graph: list[list[int]], num_colors: int) -> bool:
     """
     Solves the m-coloring problem using backtracking.
 
     Parameters:
     graph (list[list[int]]): The adjacency matrix of the graph.
-    m (int): The maximum number of colors.
+    num_colors (int): The maximum number of colors.
 
     Returns:
-    bool: True if the graph can be colored with `m` colors, otherwise False.
+    bool: True if the graph can be colored with `num_colors` colors, otherwise False.
 
     Example:
     >>> graph = [[0, 1, 1], [1, 0, 1], [1, 1, 0]]
     >>> graph_coloring(graph, 3)
     True
     """
     color = [-1] * len(graph)
-    return graph_coloring_util(graph, m, color, 0)
+    return graph_coloring_util(graph, num_colors, color, 0)