Refactor graph coloring algorithm for improved efficiency

Author: JabedWeb

color.py

@@ -39,3 +39,69 @@ def graph_coloring(self, m):
            [1, 0, 1, 0]]
 m = 3  # Number of colors
 g.graph_coloring(m)
+
+
+
+
+--------**
+g1={
+        0:[1,2],
+        1:[2,3,0],
+        2:[3,1,0],
+        3:[1,2,4],
+        4:[3]
+    }
+
+# Assigns colors (starting from 0) to all
+# vertices and prints the assignment of colors
+def greedyColoring(adj, V):
+     
+    result = [-1] * V
+    print(result)
+ 
+    # Assign the first color to first vertex
+    result[0] = 0;
+ 
+ 
+    # A temporary array to store the available colors.
+    # True value of available[cr] would mean that the
+    # color cr is assigned to one of its adjacent vertices
+    available = [False] * V
+    print(available)
+ 
+    # Assign colors to remaining V-1 vertices
+    for u in range(1, V): #1
+         
+        # Process all adjacent vertices and
+        # flag their colors as unavailable
+        print(result)
+        print(available)
+        for i in adj[u]:
+            if (result[i] != -1):
+                available[result[i]] = True
+                print(available)
+ 
+        # Find the first available color
+        cr = 0
+        while cr < V:
+            if (available[cr] == False):
+                break
+             
+            cr += 1
+             
+        # Assign the found color
+        result[u] = cr
+ 
+        # Reset the values back to false
+        # for the next iteration
+        for i in adj[u]:
+            if (result[i] != -1):
+                available[result[i]] = False
+ 
+    # Print the result
+    for u in range(V):
+        print("Vertex", u, " --->  Color", result[u])
+
+
+print("Coloring of graph 1 ")
+greedyColoring(g1, 5)

idfs.py

@@ -37,3 +37,60 @@ def iddfs(graph, start, target, max_depth):
     print(f"Found target {target} within depth {max_depth}")
 else:
     print(f"Target {target} not found within depth {max_depth}")
+
+
+
+----------
+graph = {
+    'A': ['B', 'C', 'D'],
+    'B': ['A', 'E', 'F'],
+    'C': ['A', 'G'],
+    'D': ['A','H','J'],
+    'E': ['B', 'K', 'L'],
+    'F': ['B'],
+    'G': ['C', 'M'],
+    'H': ['D', 'N', 'O'],
+    'J': ['D', 'P'],
+    'K': ['E'],
+    'L': ['E'],
+    'M': ['G'],
+    'N': ['H'],
+    'O': ['H'],
+    'P': ['J']
+}
+
+
+
+
+# here i am just call ids method by passing max level. then running a loop and call dls function.
+def ids(graph, start, max_limit):
+    for i in range(max_limit):
+        dls(graph, start, i)
+
+
+
+
+
+
+def dls(graph, start,  limit):
+    visited = []
+    stack = [(start, 0)]  
+
+
+    while stack:
+        current_node, current_depth = stack.pop()
+
+
+        if current_depth <=  limit:
+            if current_node not in visited:
+                visited.append(current_node)
+                neighbors = graph[current_node]
+
+
+                for neighbor in neighbors:
+                    stack.append((neighbor, current_depth + 1))
+    print(visited)
+   
+
+
+print(ids(graph, 'A', 4))

quN.py

@@ -4,30 +4,45 @@ def print_solution(board):
     print()
 
 def is_safe(board, row, col):
+    # Check this row on the left side
     for i in range(col):
         if board[row][i] == 1:
             return False
 
-    for i, j in zip(range(row, -1, -1), range(col, -1, -1)):
+    # Check upper diagonal on the left side
+    i, j = row, col
+    while i >= 0 and j >= 0:
         if board[i][j] == 1:
             return False
+        i -= 1
+        j -= 1
 
-    for i, j in zip(range(row, len(board), 1), range(col, -1, -1)):
+    # Check lower diagonal on the left side
+    i, j = row, col
+    while i < len(board) and j >= 0:
         if board[i][j] == 1:
             return False
+        i += 1
+        j -= 1
 
     return True
 
 def solve_nq_util(board, col):
     if col >= len(board):
+        print("All queens successfully placed:")
+        print_solution(board)
         return True
 
     for i in range(len(board)):
         if is_safe(board, i, col):
             board[i][col] = 1
+            print(f"Placed queen at ({i}, {col}):")
+            print_solution(board)
             if solve_nq_util(board, col + 1):
                 return True
             board[i][col] = 0
+            print(f"Backtracked from ({i}, {col}):")
+            print_solution(board)
 
     return False
 
@@ -40,4 +55,8 @@ def solve_nq(n):
     print_solution(board)
     return True
 
+<<<<<<< HEAD
 solve_nq(8)
+=======
+solve_nq(8)
+>>>>>>> 52cc3477255fdcf42a9a7863d163d09ee1f7c3db