Skip to content
Related Articles

Related Articles

m Coloring Problem | Backtracking-5

Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 23 Sep, 2022
Improve Article
Save Article

Given an undirected graph and a number m, determine if the graph can be colored with at most m colors such that no two adjacent vertices of the graph are colored with the same color

Note: Here coloring of a graph means the assignment of colors to all vertices

Following is an example of a graph that can be colored with 3 different colors:
 

example of a graph that can be coloured with 3 different colours

Examples: 

Input:  graph = {0, 1, 1, 1},
                         {1, 0, 1, 0},
                         {1, 1, 0, 1},
                         {1, 0, 1, 0}
Output: Solution Exists: Following are the assigned colors: 1  2  3  2
Explanation: By coloring the vertices 
                      with following colors, adjacent 
                      vertices does not have same colors

Input: graph = {1, 1, 1, 1},
                         {1, 1, 1, 1},
                         {1, 1, 1, 1},
                         {1, 1, 1, 1}

Output: Solution does not exist
Explanation: No solution exits 

We strongly recommend that you click here and practice it, before moving on to the solution.

Naive Approach: To solve the problem follow the below idea:

Generate all possible configurations of colors. Since each node can be colored using any of the m available colors, the total number of color configurations possible is mV. After generating a configuration of color, check if the adjacent vertices have the same color or not. If the conditions are met, print the combination and break the loop

Follow the given steps to solve the problem:

  • Create a recursive function that takes the current index, number of vertices and output color array
  • If the current index is equal to number of vertices. Check if the output color configuration is safe, i.e check if the adjacent vertices do not have same color. If the conditions are met, print the configuration and break
  • Assign a color to a vertex (1 to m)
  • For every assigned color recursively call the function with next index and number of vertices
  • If any recursive function returns true break the loop and returns true.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Number of vertices in the graph
#define V 4
 
void printSolution(int color[]);
 
// check if the colored
// graph is safe or not
bool isSafe(bool graph[V][V], int color[])
{
    // check for every edge
    for (int i = 0; i < V; i++)
        for (int j = i + 1; j < V; j++)
            if (graph[i][j] && color[j] == color[i])
                return false;
    return true;
}
 
/* This function solves the m Coloring
problem using recursion. It returns
false if the m colours cannot be assigned,
otherwise, return true and prints
assignments of colours to all vertices.
Please note that there may be more than
one solutions, this function prints one
of the feasible solutions.*/
bool graphColoring(bool graph[V][V], int m, int i,
                   int color[V])
{
    // if current index reached end
    if (i == V) {
 
        // if coloring is safe
        if (isSafe(graph, color)) {
 
            // Print the solution
            printSolution(color);
            return true;
        }
        return false;
    }
 
    // Assign each color from 1 to m
    for (int j = 1; j <= m; j++) {
        color[i] = j;
 
        // Recur of the rest vertices
        if (graphColoring(graph, m, i + 1, color))
            return true;
 
        color[i] = 0;
    }
 
    return false;
}
 
/* A utility function to print solution */
void printSolution(int color[])
{
    cout << "Solution Exists:"
            " Following are the assigned colors \n";
    for (int i = 0; i < V; i++)
        cout << "  " << color[i];
    cout << "\n";
}
 
// Driver code
int main()
{
    /* Create following graph and
    test whether it is 3 colorable
    (3)---(2)
    | / |
    | / |
    | / |
    (0)---(1)
    */
    bool graph[V][V] = {
        { 0, 1, 1, 1 },
        { 1, 0, 1, 0 },
        { 1, 1, 0, 1 },
        { 1, 0, 1, 0 },
    };
    int m = 3; // Number of colors
 
    // Initialize all color values as 0.
    // This initialization is needed
    // correct functioning of isSafe()
    int color[V];
    for (int i = 0; i < V; i++)
        color[i] = 0;
 
    // Function call
    if (!graphColoring(graph, m, 0, color))
        cout << "Solution does not exist";
 
    return 0;
}
 
// This code is contributed by shivanisinghss2110

C




// C program for the above approach
 
#include <stdbool.h>
#include <stdio.h>
 
// Number of vertices in the graph
#define V 4
 
void printSolution(int color[]);
 
// check if the colored
// graph is safe or not
bool isSafe(bool graph[V][V], int color[])
{
    // check for every edge
    for (int i = 0; i < V; i++)
        for (int j = i + 1; j < V; j++)
            if (graph[i][j] && color[j] == color[i])
                return false;
    return true;
}
 
/* This function solves the m Coloring
   problem using recursion. It returns
  false if the m colours cannot be assigned,
  otherwise, return true and prints
  assignments of colours to all vertices.
  Please note that there may be more than
  one solutions, this function prints one
  of the feasible solutions.*/
bool graphColoring(bool graph[V][V], int m, int i,
                   int color[V])
{
    // if current index reached end
    if (i == V) {
        // if coloring is safe
        if (isSafe(graph, color)) {
            // Print the solution
            printSolution(color);
            return true;
        }
        return false;
    }
 
    // Assign each color from 1 to m
    for (int j = 1; j <= m; j++) {
        color[i] = j;
 
        // Recur of the rest vertices
        if (graphColoring(graph, m, i + 1, color))
            return true;
 
        color[i] = 0;
    }
 
    return false;
}
 
/* A utility function to print solution */
void printSolution(int color[])
{
    printf("Solution Exists:"
           " Following are the assigned colors \n");
    for (int i = 0; i < V; i++)
        printf(" %d ", color[i]);
    printf("\n");
}
 
// Driver code
int main()
{
    /* Create following graph and
       test whether it is 3 colorable
      (3)---(2)
       |   / |
       |  /  |
       | /   |
      (0)---(1)
    */
    bool graph[V][V] = {
        { 0, 1, 1, 1 },
        { 1, 0, 1, 0 },
        { 1, 1, 0, 1 },
        { 1, 0, 1, 0 },
    };
    int m = 3; // Number of colors
 
    // Initialize all color values as 0.
    // This initialization is needed
    // correct functioning of isSafe()
    int color[V];
    for (int i = 0; i < V; i++)
        color[i] = 0;
 
    // Function call
    if (!graphColoring(graph, m, 0, color))
        printf("Solution does not exist");
 
    return 0;
}

Java




// Java program for the above approach
 
public class GFG {
 
    // Number of vertices in the graph
    static int V = 4;
 
    /* A utility function to print solution */
    static void printSolution(int[] color)
    {
        System.out.println(
            "Solution Exists:"
            + " Following are the assigned colors ");
        for (int i = 0; i < V; i++)
            System.out.print("  " + color[i]);
        System.out.println();
    }
 
    // check if the colored
    // graph is safe or not
    static boolean isSafe(boolean[][] graph, int[] color)
    {
        // check for every edge
        for (int i = 0; i < V; i++)
            for (int j = i + 1; j < V; j++)
                if (graph[i][j] && color[j] == color[i])
                    return false;
        return true;
    }
 
    /* This function solves the m Coloring
      problem using recursion. It returns
      false if the m colours cannot be assigned,
      otherwise, return true and prints
      assignments of colours to all vertices.
      Please note that there may be more than
      one solutions, this function prints one
      of the feasible solutions.*/
    static boolean graphColoring(boolean[][] graph, int m,
                                 int i, int[] color)
    {
        // if current index reached end
        if (i == V) {
 
            // if coloring is safe
            if (isSafe(graph, color)) {
 
                // Print the solution
                printSolution(color);
                return true;
            }
            return false;
        }
 
        // Assign each color from 1 to m
        for (int j = 1; j <= m; j++) {
            color[i] = j;
 
            // Recur of the rest vertices
            if (graphColoring(graph, m, i + 1, color))
                return true;
            color[i] = 0;
        }
        return false;
    }
 
    // Driver code
    public static void main(String[] args)
    {
 
        /* Create following graph and
            test whether it is 3 colorable
            (3)---(2)
            | / |
            | / |
            | / |
            (0)---(1)
            */
        boolean[][] graph = {
            { false, true, true, true },
            { true, false, true, false },
            { true, true, false, true },
            { true, false, true, false },
        };
        int m = 3; // Number of colors
 
        // Initialize all color values as 0.
        // This initialization is needed
        // correct functioning of isSafe()
        int[] color = new int[V];
        for (int i = 0; i < V; i++)
            color[i] = 0;
 
        // Function call
        if (!graphColoring(graph, m, 0, color))
            System.out.println("Solution does not exist");
    }
}
 
// This code is contributed by divyeh072019.

Python3




# Python3 program for the above approach
 
# Number of vertices in the graph
# define 4 4
 
# check if the colored
# graph is safe or not
 
 
def isSafe(graph, color):
 
    # check for every edge
    for i in range(4):
        for j in range(i + 1, 4):
            if (graph[i][j] and color[j] == color[i]):
                return False
    return True
 
# /* This function solves the m Coloring
# problem using recursion. It returns
# false if the m colours cannot be assigned,
# otherwise, return true and prints
# assignments of colours to all vertices.
# Please note that there may be more than
# one solutions, this function prints one
# of the feasible solutions.*/
 
 
def graphColoring(graph, m, i, color):
 
    # if current index reached end
    if (i == 4):
 
        # if coloring is safe
        if (isSafe(graph, color)):
 
            # Print the solution
            printSolution(color)
            return True
        return False
 
    # Assign each color from 1 to m
    for j in range(1, m + 1):
        color[i] = j
 
        # Recur of the rest vertices
        if (graphColoring(graph, m, i + 1, color)):
            return True
        color[i] = 0
    return False
 
# /* A utility function to print solution */
 
 
def printSolution(color):
    print("Solution Exists:" " Following are the assigned colors ")
    for i in range(4):
        print(color[i], end=" ")
 
 
# Driver code
if __name__ == '__main__':
 
    # /* Create following graph and
    # test whether it is 3 colorable
    # (3)---(2)
    # | / |
    # | / |
    # | / |
    # (0)---(1)
    # */
    graph = [
        [0, 1, 1, 1],
        [1, 0, 1, 0],
        [1, 1, 0, 1],
        [1, 0, 1, 0],
    ]
    m = 3  # Number of colors
 
    # Initialize all color values as 0.
    # This initialization is needed
    # correct functioning of isSafe()
    color = [0 for i in range(4)]
 
    # Function call
    if (not graphColoring(graph, m, 0, color)):
        print("Solution does not exist")
 
# This code is contributed by mohit kumar 29

C#




// C# program for the above approach
 
using System;
class GFG {
 
    // Number of vertices in the graph
    static int V = 4;
 
    /* A utility function to print solution */
    static void printSolution(int[] color)
    {
        Console.WriteLine(
            "Solution Exists:"
            + " Following are the assigned colors ");
        for (int i = 0; i < V; i++)
            Console.Write("  " + color[i]);
        Console.WriteLine();
    }
 
    // check if the colored
    // graph is safe or not
    static bool isSafe(bool[, ] graph, int[] color)
    {
        // check for every edge
        for (int i = 0; i < V; i++)
            for (int j = i + 1; j < V; j++)
                if (graph[i, j] && color[j] == color[i])
                    return false;
        return true;
    }
 
    /* This function solves the m Coloring
    problem using recursion. It returns
    false if the m colours cannot be assigned,
    otherwise, return true and prints
    assignments of colours to all vertices.
    Please note that there may be more than
    one solutions, this function prints one
    of the feasible solutions.*/
    static bool graphColoring(bool[, ] graph, int m, int i,
                              int[] color)
    {
        // if current index reached end
        if (i == V) {
 
            // if coloring is safe
            if (isSafe(graph, color)) {
 
                // Print the solution
                printSolution(color);
                return true;
            }
            return false;
        }
 
        // Assign each color from 1 to m
        for (int j = 1; j <= m; j++) {
            color[i] = j;
 
            // Recur of the rest vertices
            if (graphColoring(graph, m, i + 1, color))
                return true;
 
            color[i] = 0;
        }
 
        return false;
    }
 
    // Driver code
    static void Main()
    {
        /* Create following graph and
        test whether it is 3 colorable
        (3)---(2)
        | / |
        | / |
        | / |
        (0)---(1)
        */
        bool[, ] graph = {
            { false, true, true, true },
            { true, false, true, false },
            { true, true, false, true },
            { true, false, true, false },
        };
        int m = 3; // Number of colors
 
        // Initialize all color values as 0.
        // This initialization is needed
        // correct functioning of isSafe()
        int[] color = new int[V];
        for (int i = 0; i < V; i++)
            color[i] = 0;
 
        // Function call
        if (!graphColoring(graph, m, 0, color))
            Console.WriteLine("Solution does not exist");
    }
}
 
// this code is contributed by divyeshrabadiya07.

Javascript




<script>
     
    // Number of vertices in the graph
    let V = 4;
     
    /* A utility function to print solution */
    function printSolution(color)
    {
        document.write("Solution Exists:"  +
       " Following are the assigned colors <br>");
        for (let i = 0; i < V; i++)
              document.write("   " + color[i]);
        document.write(" ");
    }
     
    // check if the colored
  // graph is safe or not
    function isSafe(graph,color)
    {
        // check for every edge
    for (let i = 0; i < V; i++)
      for (let j = i + 1; j < V; j++)
        if (graph[i][j] && color[j] == color[i])
          return false;
    return true;
    }
     
     
  /* This function solves the m Coloring
    problem using recursion. It returns
    false if the m colours cannot be assigned,
    otherwise, return true and prints
    assignments of colours to all vertices.
    Please note that there may be more than
    one solutions, this function prints one
    of the feasible solutions.*/
    function graphColoring(graph,m,i,color)
    {
        // if current index reached end
    if (i == V) {
  
      // if coloring is safe
      if (isSafe(graph, color))
      {
  
        // Print the solution
        printSolution(color);
        return true;
      }
      return false;
      }
  
    // Assign each color from 1 to m
    for (let j = 1; j <= m; j++)
    {
      color[i] = j;
  
      // Recur of the rest vertices
      if (graphColoring(graph, m, i + 1, color))
        return true;
      color[i] = 0;
    }
    return false;
    }
     
    // Driver code
     
    /* Create following graph and
        test whether it is 3 colorable
        (3)---(2)
        | / |
        | / |
        | / |
        (0)---(1)
        */
    let graph=[[ false, true, true, true],
               [ true, false, true, false ],
               [ true, true, false, true ],
               [true, false, true, false]];
     
    let m = 3; // Number of colors
     
    // Initialize all color values as 0.
    // This initialization is needed
    // correct functioning of isSafe()
    let color = new Array(V);
    for (let i = 0; i < V; i++)
      color[i] = 0;
       
    if (!graphColoring(graph, m, 0, color))
      document.write("Solution does not exist");
     
    
    // This code is contributed by unknown2108
     
</script>

Output

Solution Exists: Following are the assigned colors 
  1  2  3  2

Time Complexity: O(mV). There is a total O(mV) combination of colors
Auxiliary Space: O(V). Recursive Stack of graph coloring(…) function will require O(V) space.

m Coloring Problem using Backtracking:

To solve the problem follow the below idea:

The idea is to assign colors one by one to different vertices, starting from vertex 0. Before assigning a color, check for safety by considering already assigned colors to the adjacent vertices i.e check if the adjacent vertices have the same color or not. If there is any color assignment that does not violate the conditions, mark the color assignment as part of the solution. If no assignment of color is possible then backtrack and return false

Follow the given steps to solve the problem:

  • Create a recursive function that takes the graph, current index, number of vertices, and output color array.
  • If the current index is equal to the number of vertices. Print the color configuration in the output array.
  • Assign a color to a vertex (1 to m).
  • For every assigned color, check if the configuration is safe, (i.e. check if the adjacent vertices do not have the same color) recursively call the function with the next index and number of vertices
  • If any recursive function returns true break the loop and return true
  • If no recursive function returns true then return false

Below is the implementation of the above approach:

C++




// C++ program for solution of M
// Coloring problem using backtracking
 
#include <bits/stdc++.h>
using namespace std;
 
// Number of vertices in the graph
#define V 4
 
void printSolution(int color[]);
 
/* A utility function to check if
   the current color assignment
   is safe for vertex v i.e. checks
   whether the edge exists or not
   (i.e, graph[v][i]==1). If exist
   then checks whether the color to
   be filled in the new vertex(c is
   sent in the parameter) is already
   used by its adjacent
   vertices(i-->adj vertices) or
   not (i.e, color[i]==c) */
bool isSafe(int v, bool graph[V][V], int color[], int c)
{
    for (int i = 0; i < V; i++)
        if (graph[v][i] && c == color[i])
            return false;
 
    return true;
}
 
/* A recursive utility function
to solve m coloring problem */
bool graphColoringUtil(bool graph[V][V], int m, int color[],
                       int v)
{
 
    /* base case: If all vertices are
       assigned a color then return true */
    if (v == V)
        return true;
 
    /* Consider this vertex v and
       try different colors */
    for (int c = 1; c <= m; c++) {
 
        /* Check if assignment of color
           c to v is fine*/
        if (isSafe(v, graph, color, c)) {
            color[v] = c;
 
            /* recur to assign colors to
               rest of the vertices */
            if (graphColoringUtil(graph, m, color, v + 1)
                == true)
                return true;
 
            /* If assigning color c doesn't
               lead to a solution then remove it */
            color[v] = 0;
        }
    }
 
    /* If no color can be assigned to
       this vertex then return false */
    return false;
}
 
/* This function solves the m Coloring
   problem using Backtracking. It mainly
   uses graphColoringUtil() to solve the
   problem. It returns false if the m
   colors cannot be assigned, otherwise
   return true and prints assignments of
   colors to all vertices. Please note
   that there may be more than one solutions,
   this function prints one of the
   feasible solutions.*/
bool graphColoring(bool graph[V][V], int m)
{
 
    // Initialize all color values as 0.
    // This initialization is needed
    // correct functioning of isSafe()
    int color[V];
    for (int i = 0; i < V; i++)
        color[i] = 0;
 
    // Call graphColoringUtil() for vertex 0
    if (graphColoringUtil(graph, m, color, 0) == false) {
        cout << "Solution does not exist";
        return false;
    }
 
    // Print the solution
    printSolution(color);
    return true;
}
 
/* A utility function to print solution */
void printSolution(int color[])
{
    cout << "Solution Exists:"
         << " Following are the assigned colors"
         << "\n";
    for (int i = 0; i < V; i++)
        cout << " " << color[i] << " ";
 
    cout << "\n";
}
 
// Driver code
int main()
{
 
    /* Create following graph and test
       whether it is 3 colorable
      (3)---(2)
       |   / |
       |  /  |
       | /   |
      (0)---(1)
    */
    bool graph[V][V] = {
        { 0, 1, 1, 1 },
        { 1, 0, 1, 0 },
        { 1, 1, 0, 1 },
        { 1, 0, 1, 0 },
    };
 
    // Number of colors
    int m = 3;
 
    // Function call
    graphColoring(graph, m);
    return 0;
}
 
// This code is contributed by Shivani

C




// C program for solution of M
// Coloring problem using backtracking
 
#include <stdbool.h>
#include <stdio.h>
 
// Number of vertices in the graph
#define V 4
 
void printSolution(int color[]);
 
/* A utility function to check if
   the current color assignment
   is safe for vertex v i.e. checks
   whether the edge exists or not
   (i.e, graph[v][i]==1). If exist
   then checks whether the color to
   be filled in the new vertex(c is
   sent in the parameter) is already
   used by its adjacent
   vertices(i-->adj vertices) or
   not (i.e, color[i]==c) */
bool isSafe(int v, bool graph[V][V], int color[], int c)
{
    for (int i = 0; i < V; i++)
        if (graph[v][i] && c == color[i])
            return false;
    return true;
}
 
/* A recursive utility function
to solve m coloring problem */
bool graphColoringUtil(bool graph[V][V], int m, int color[],
                       int v)
{
    /* base case: If all vertices are
       assigned a color then return true */
    if (v == V)
        return true;
 
    /* Consider this vertex v and
       try different colors */
    for (int c = 1; c <= m; c++) {
        /* Check if assignment of color
           c to v is fine*/
        if (isSafe(v, graph, color, c)) {
            color[v] = c;
 
            /* recur to assign colors to
               rest of the vertices */
            if (graphColoringUtil(graph, m, color, v + 1)
                == true)
                return true;
 
            /* If assigning color c doesn't
               lead to a solution then remove it */
            color[v] = 0;
        }
    }
 
    /* If no color can be assigned to
       this vertex then return false */
    return false;
}
 
/* This function solves the m Coloring
   problem using Backtracking. It mainly
   uses graphColoringUtil() to solve the
   problem. It returns false if the m
   colors cannot be assigned, otherwise
   return true and prints assignments of
   colors to all vertices. Please note
   that there may be more than one solutions,
   this function prints one of the
   feasible solutions.*/
bool graphColoring(bool graph[V][V], int m)
{
    // Initialize all color values as 0.
    // This initialization is needed
    // correct functioning of isSafe()
    int color[V];
    for (int i = 0; i < V; i++)
        color[i] = 0;
 
    // Call graphColoringUtil() for vertex 0
    if (graphColoringUtil(graph, m, color, 0) == false) {
        printf("Solution does not exist");
        return false;
    }
 
    // Print the solution
    printSolution(color);
    return true;
}
 
/* A utility function to print solution */
void printSolution(int color[])
{
    printf("Solution Exists:"
           " Following are the assigned colors \n");
    for (int i = 0; i < V; i++)
        printf(" %d ", color[i]);
    printf("\n");
}
 
// Driver code
int main()
{
    /* Create following graph and test
       whether it is 3 colorable
      (3)---(2)
       |   / |
       |  /  |
       | /   |
      (0)---(1)
    */
    bool graph[V][V] = {
        { 0, 1, 1, 1 },
        { 1, 0, 1, 0 },
        { 1, 1, 0, 1 },
        { 1, 0, 1, 0 },
    };
    int m = 3; // Number of colors
 
    // Function call
    graphColoring(graph, m);
    return 0;
}

Java




/* Java program for solution of
   M Coloring problem using backtracking */
 
public class mColoringProblem {
    final int V = 4;
    int color[];
 
    /* A utility function to check
       if the current color assignment
       is safe for vertex v */
    boolean isSafe(int v, int graph[][], int color[], int c)
    {
        for (int i = 0; i < V; i++)
            if (graph[v][i] == 1 && c == color[i])
                return false;
        return true;
    }
 
    /* A recursive utility function
       to solve m coloring  problem */
    boolean graphColoringUtil(int graph[][], int m,
                              int color[], int v)
    {
        /* base case: If all vertices are
           assigned a color then return true */
        if (v == V)
            return true;
 
        /* Consider this vertex v and try
           different colors */
        for (int c = 1; c <= m; c++) {
            /* Check if assignment of color c to v
               is fine*/
            if (isSafe(v, graph, color, c)) {
                color[v] = c;
 
                /* recur to assign colors to rest
                   of the vertices */
                if (graphColoringUtil(graph, m, color,
                                      v + 1))
                    return true;
 
                /* If assigning color c doesn't lead
                   to a solution then remove it */
                color[v] = 0;
            }
        }
 
        /* If no color can be assigned to
           this vertex then return false */
        return false;
    }
 
    /* This function solves the m Coloring problem using
       Backtracking. It mainly uses graphColoringUtil()
       to solve the problem. It returns false if the m
       colors cannot be assigned, otherwise return true
       and  prints assignments of colors to all vertices.
       Please note that there  may be more than one
       solutions, this function prints one of the
       feasible solutions.*/
    boolean graphColoring(int graph[][], int m)
    {
        // Initialize all color values as 0. This
        // initialization is needed correct
        // functioning of isSafe()
        color = new int[V];
        for (int i = 0; i < V; i++)
            color[i] = 0;
 
        // Call graphColoringUtil() for vertex 0
        if (!graphColoringUtil(graph, m, color, 0)) {
            System.out.println("Solution does not exist");
            return false;
        }
 
        // Print the solution
        printSolution(color);
        return true;
    }
 
    /* A utility function to print solution */
    void printSolution(int color[])
    {
        System.out.println("Solution Exists: Following"
                           + " are the assigned colors");
        for (int i = 0; i < V; i++)
            System.out.print(" " + color[i] + " ");
        System.out.println();
    }
 
    // Driver code
    public static void main(String args[])
    {
        mColoringProblem Coloring = new mColoringProblem();
        /* Create following graph and
           test whether it is
           3 colorable
          (3)---(2)
           |   / |
           |  /  |
           | /   |
          (0)---(1)
        */
        int graph[][] = {
            { 0, 1, 1, 1 },
            { 1, 0, 1, 0 },
            { 1, 1, 0, 1 },
            { 1, 0, 1, 0 },
        };
        int m = 3; // Number of colors
 
        // Function call
        Coloring.graphColoring(graph, m);
    }
}
// This code is contributed by Abhishek Shankhadhar

Python3




# Python3 program for solution of M Coloring
# problem using backtracking
 
 
class Graph():
 
    def __init__(self, vertices):
        self.V = vertices
        self.graph = [[0 for column in range(vertices)]
                      for row in range(vertices)]
 
    # A utility function to check
    # if the current color assignment
    # is safe for vertex v
    def isSafe(self, v, colour, c):
        for i in range(self.V):
            if self.graph[v][i] == 1 and colour[i] == c:
                return False
        return True
 
    # A recursive utility function to solve m
    # coloring  problem
    def graphColourUtil(self, m, colour, v):
        if v == self.V:
            return True
 
        for c in range(1, m + 1):
            if self.isSafe(v, colour, c) == True:
                colour[v] = c
                if self.graphColourUtil(m, colour, v + 1) == True:
                    return True
                colour[v] = 0
 
    def graphColouring(self, m):
        colour = [0] * self.V
        if self.graphColourUtil(m, colour, 0) == None:
            return False
 
        # Print the solution
        print("Solution exist and Following are the assigned colours:")
        for c in colour:
            print(c, end=' ')
        return True
 
 
# Driver Code
if __name__ == '__main__':
    g = Graph(4)
    g.graph = [[0, 1, 1, 1], [1, 0, 1, 0], [1, 1, 0, 1], [1, 0, 1, 0]]
    m = 3
 
    # Function call
    g.graphColouring(m)
 
# This code is contributed by Divyanshu Mehta

C#




/* C# program for solution of M Coloring problem
using backtracking */
using System;
 
class GFG {
    readonly int V = 4;
    int[] color;
 
    /* A utility function to check if the current
    color assignment is safe for vertex v */
    bool isSafe(int v, int[, ] graph, int[] color, int c)
    {
        for (int i = 0; i < V; i++)
            if (graph[v, i] == 1 && c == color[i])
                return false;
        return true;
    }
 
    /* A recursive utility function to solve m
    coloring problem */
    bool graphColoringUtil(int[, ] graph, int m,
                           int[] color, int v)
    {
        /* base case: If all vertices are assigned
        a color then return true */
        if (v == V)
            return true;
 
        /* Consider this vertex v and try different
        colors */
        for (int c = 1; c <= m; c++) {
            /* Check if assignment of color c to v
            is fine*/
            if (isSafe(v, graph, color, c)) {
                color[v] = c;
 
                /* recur to assign colors to rest
                of the vertices */
                if (graphColoringUtil(graph, m, color,
                                      v + 1))
                    return true;
 
                /* If assigning color c doesn't lead
                to a solution then remove it */
                color[v] = 0;
            }
        }
 
        /* If no color can be assigned to this vertex
        then return false */
        return false;
    }
 
    /* This function solves the m Coloring problem using
    Backtracking. It mainly uses graphColoringUtil()
    to solve the problem. It returns false if the m
    colors cannot be assigned, otherwise return true
    and prints assignments of colors to all vertices.
    Please note that there may be more than one
    solutions, this function prints one of the
    feasible solutions.*/
    bool graphColoring(int[, ] graph, int m)
    {
        // Initialize all color values as 0. This
        // initialization is needed correct functioning
        // of isSafe()
        color = new int[V];
        for (int i = 0; i < V; i++)
            color[i] = 0;
 
        // Call graphColoringUtil() for vertex 0
        if (!graphColoringUtil(graph, m, color, 0)) {
            Console.WriteLine("Solution does not exist");
            return false;
        }
 
        // Print the solution
        printSolution(color);
        return true;
    }
 
    /* A utility function to print solution */
    void printSolution(int[] color)
    {
        Console.WriteLine("Solution Exists: Following"
                          + " are the assigned colors");
        for (int i = 0; i < V; i++)
            Console.Write(" " + color[i] + " ");
        Console.WriteLine();
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        GFG Coloring = new GFG();
 
        /* Create following graph and test whether it is
        3 colorable
        (3)---(2)
        | / |
        | / |
        | / |
        (0)---(1)
        */
        int[, ] graph = { { 0, 1, 1, 1 },
                          { 1, 0, 1, 0 },
                          { 1, 1, 0, 1 },
                          { 1, 0, 1, 0 } };
        int m = 3; // Number of colors
 
        // Function call
        Coloring.graphColoring(graph, m);
    }
}
 
// This code is contributed by PrinciRaj1992

Javascript




<script>
 
/* JavaScript program for solution of
   M Coloring problem using backtracking */
 
let V = 4;
let color;
 
/* A utility function to check
       if the current color assignment
       is safe for vertex v */
function isSafe(v,graph,color,c)
{
    for (let i = 0; i < V; i++)
            if (
                graph[v][i] == 1 && c == color[i])
                return false;
        return true;
}
 
/* A recursive utility function
       to solve m coloring  problem */
function graphColoringUtil(graph,m,color,v)
{
    /* base case: If all vertices are
           assigned a color then return true */
        if (v == V)
            return true;
  
        /* Consider this vertex v and try
           different colors */
        for (let c = 1; c <= m; c++)
        {
            /* Check if assignment of color c to v
               is fine*/
            if (isSafe(v, graph, color, c))
            {
                color[v] = c;
  
                /* recur to assign colors to rest
                   of the vertices */
                if (
                    graphColoringUtil(
                        graph, m,
                        color, v + 1))
                    return true;
  
                /* If assigning color c doesn't lead
                   to a solution then remove it */
                color[v] = 0;
            }
        }
  
        /* If no color can be assigned to
           this vertex then return false */
        return false;
}
 
/* This function solves the m Coloring problem using
       Backtracking. It mainly uses graphColoringUtil()
       to solve the problem. It returns false if the m
       colors cannot be assigned, otherwise return true
       and  prints assignments of colors to all vertices.
       Please note that there  may be more than one
       solutions, this function prints one of the
       feasible solutions.*/
function graphColoring(graph,m)
{
    // Initialize all color values as 0. This
        // initialization is needed correct
        // functioning of isSafe()
        color = new Array(V);
        for (let i = 0; i < V; i++)
            color[i] = 0;
  
        // Call graphColoringUtil() for vertex 0
        if (
            !graphColoringUtil(
                graph, m, color, 0))
        {
            document.write(
                "Solution does not exist<br>");
            return false;
        }
  
        // Print the solution
        printSolution(color);
        return true;
}
 
/* A utility function to print solution */
function printSolution(color)
{
    document.write(
            "Solution Exists: Following"
            + " are the assigned colors<br>");
        for (let i = 0; i < V; i++)
            document.write(" " + color[i] + " ");
        document.write("<br>");
}
 
 // driver program to test above function
/* Create following graph and
           test whether it is
           3 colorable
          (3)---(2)
           |   / |
           |  /  |
           | /   |
          (0)---(1)
        */
        let graph = [
            [ 0, 1, 1, 1 ],
            [ 1, 0, 1, 0 ],
            [ 1, 1, 0, 1 ],
            [ 1, 0, 1, 0 ],
        ];
        let m = 3; // Number of colors
        graphColoring(graph, m);
 
     
 
 
// This code is contributed by ab2127
 
</script>

Output

Solution Exists: Following are the assigned colors 
 1  2  3  2 

Time Complexity: O(mV). There is a total of O(mV) combinations of colors. The upper bound time complexity remains the same but the average time taken will be less.
Auxiliary Space: O(V). The recursive Stack of the graph coloring function will require O(V) space.

m Coloring Problem using BFS:

To solve the problem follow the below idea:

The approach here is to color each node from 1 to n initially by color 1. And start traveling BFS from an unvisited starting node to cover all connected components in one go. On reaching each node during BFS traversal, do the following:

Follow the given steps to solve the problem:

  • Check all edges of the given node
  • For each vertex connected to our node via an edge:
    • check if the color of the nodes is the same. If the same, increase the color of the other node (not the current) by one
    • to check if it is visited or unvisited. If not visited, mark it as visited and push it into a queue
  • Check condition for maxColors till now. If it exceeds M, return false
  • After visiting all nodes, return true (As no violating condition could be found while traveling)

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
class node {
 
    // A node class which stores the color and the edges
    // connected to the node
public:
    int color = 1;
    set<int> edges;
};
 
int canPaint(vector<node>& nodes, int n, int m)
{
 
    // Create a visited array of n
    // nodes, initialized to zero
    vector<int> visited(n + 1, 0);
 
    // maxColors used till now are 1 as
    // all nodes are painted color 1
    int maxColors = 1;
 
    // Do a full BFS traversal from
    // all unvisited starting points
    for (int sv = 1; sv <= n; sv++) {
 
        if (visited[sv])
            continue;
 
        // If the starting point is unvisited,
        // mark it visited and push it in queue
        visited[sv] = 1;
        queue<int> q;
        q.push(sv);
 
        // BFS Travel starts here
        while (!q.empty()) {
 
            int top = q.front();
            q.pop();
 
            // Checking all adjacent nodes
            // to "top" edge in our queue
            for (auto it = nodes[top].edges.begin();
                 it != nodes[top].edges.end(); it++) {
 
                // IMPORTANT: If the color of the
                // adjacent node is same, increase it by 1
                if (nodes[top].color == nodes[*it].color)
                    nodes[*it].color += 1;
 
                // If number of colors used shoots m, return
                // 0
                maxColors
                    = max(maxColors, max(nodes[top].color,
                                         nodes[*it].color));
                if (maxColors > m)
                    return 0;
 
                // If the adjacent node is not visited,
                // mark it visited and push it in queue
                if (!visited[*it]) {
                    visited[*it] = 1;
                    q.push(*it);
                }
            }
        }
    }
 
    return 1;
}
 
// Driver code
int main()
{
 
    int n = 4;
    bool graph[n][n] = { { 0, 1, 1, 1 },
                         { 1, 0, 1, 0 },
                         { 1, 1, 0, 1 },
                         { 1, 0, 1, 0 } };
    int m = 3; // Number of colors
 
    // Create a vector of n+1
    // nodes of type "node"
    // The zeroth position is just
    // dummy (1 to n to be used)
    vector<node> nodes(n + 1);
 
    // Add edges to each node as per given input
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (graph[i][j]) {
                // Connect the undirected graph
                nodes[i].edges.insert(i);
                nodes[j].edges.insert(j);
            }
        }
    }
 
    // Function call
    cout << canPaint(nodes, n, m);
    cout << "\n";
 
    return 0;
}

Java




// Java program for the above approach
 
import java.io.*;
import java.util.*;
class Node {
 
    // A node class which stores the color and the edges
    // connected to the node
    int color = 1;
    Set<Integer> edges = new HashSet<Integer>();
}
class GFG {
    static int canPaint(ArrayList<Node> nodes, int n, int m)
    {
 
        // Create a visited array of n
        // nodes, initialized to zero
        ArrayList<Integer> visited
            = new ArrayList<Integer>();
        for (int i = 0; i < n + 1; i++) {
            visited.add(0);
        }
 
        // maxColors used till now are 1 as
        // all nodes are painted color 1
        int maxColors = 1;
 
        // Do a full BFS traversal from
        // all unvisited starting points
        for (int sv = 1; sv <= n; sv++) {
            if (visited.get(sv) > 0) {
                continue;
            }
 
            // If the starting point is unvisited,
            // mark it visited and push it in queue
            visited.set(sv, 1);
            Queue<Integer> q = new LinkedList<>();
            q.add(sv);
 
            // BFS Travel starts here
            while (q.size() != 0) {
                int top = q.peek();
                q.remove();
 
                // Checking all adjacent nodes
                // to "top" edge in our queue
                for (int it : nodes.get(top).edges) {
 
                    // IMPORTANT: If the color of the
                    // adjacent node is same, increase it by
                    // 1
                    if (nodes.get(top).color
                        == nodes.get(it).color) {
                        nodes.get(it).color += 1;
                    }
 
                    // If number of colors used shoots m,
                    // return
                    // 0
                    maxColors = Math.max(
                        maxColors,
                        Math.max(nodes.get(top).color,
                                 nodes.get(it).color));
                    if (maxColors > m)
                        return 0;
 
                    // If the adjacent node is not visited,
                    // mark it visited and push it in queue
                    if (visited.get(it) == 0) {
                        visited.set(it, 1);
                        q.add(it);
                    }
                }
            }
        }
        return 1;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int n = 4;
        int[][] graph = { { 0, 1, 1, 1 },
                          { 1, 0, 1, 0 },
                          { 1, 1, 0, 1 },
                          { 1, 0, 1, 0 } };
        int m = 3; // Number of colors
 
        // Create a vector of n+1
        // nodes of type "node"
        // The zeroth position is just
        // dummy (1 to n to be used)
        ArrayList<Node> nodes = new ArrayList<Node>();
 
        for (int i = 0; i < n + 1; i++) {
            nodes.add(new Node());
        }
 
        // Add edges to each node as per given input
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (graph[i][j] > 0) {
                    // Connect the undirected graph
                    nodes.get(i).edges.add(i);
                    nodes.get(j).edges.add(j);
                }
            }
        }
 
        // Function call
        System.out.println(canPaint(nodes, n, m));
    }
}
 
// This code is contributed by avanitrachhadiya2155

Python3




# Python3 program for the above approach
 
from queue import Queue
 
 
class node:
 
    color = 1
    edges = set()
 
 
def canPaint(nodes, n, m):
 
    # Create a visited array of n
    # nodes, initialized to zero
    visited = [0 for _ in range(n+1)]
 
    # maxColors used till now are 1 as
    # all nodes are painted color 1
    maxColors = 1
 
    # Do a full BFS traversal from
    # all unvisited starting points
    for _ in range(1, n + 1):
        if visited[_]:
            continue
 
        # If the starting point is unvisited,
        # mark it visited and push it in queue
        visited[_] = 1
        q = Queue()
        q.put(_)
 
        # BFS Travel starts here
        while not q.empty():
            top = q.get()
 
            # Checking all adjacent nodes
            # to "top" edge in our queue
            for _ in nodes[top].edges:
 
                # IMPORTANT: If the color of the
                # adjacent node is same, increase it by 1
 
                if nodes[top].color == nodes[_].color:
                    nodes[_].color += 1
 
                # If number of colors used shoots m,
                # return 0
                maxColors = max(maxColors, max(
                    nodes[top].color, nodes[_].color))
 
                if maxColors > m:
                    print(maxColors)
                    return 0
 
                # If the adjacent node is not visited,
                # mark it visited and push it in queue
                if not visited[_]:
                    visited[_] = 1
                    q.put(_)
 
    return 1
 
 
# Driver code
if __name__ == "__main__":
 
    n = 4
    graph = [[0, 1, 1, 1],
             [1, 0, 1, 0],
             [1, 1, 0, 1],
             [1, 0, 1, 0]]
 
    # Number of colors
    m = 3
 
    # Create a vector of n+1
    # nodes of type "node"
    # The zeroth position is just
    # dummy (1 to n to be used)
    nodes = []
    for _ in range(n+1):
        nodes.append(node())
 
    # Add edges to each node as
    # per given input
    for _ in range(n):
        for __ in range(n):
            if graph[_][__]:
 
                # Connect the undirected graph
                nodes[_].edges.add(_)
                nodes[__].edges.add(__)
 
    # Function call
    print(canPaint(nodes, n, m))
 
# This code is contributed by harshitkap00r

C#




// C# program for the above approach
 
using System;
using System.Collections;
using System.Collections.Generic;
class GFG {
 
    class node {
 
        // A node class which stores the color and the edges
        // connected to the node
        public int color = 1;
        public HashSet<int> edges = new HashSet<int>();
    };
 
    static int canPaint(List<node> nodes, int n, int m)
    {
 
        // Create a visited array of n
        // nodes, initialized to zero
        List<int> visited = new List<int>();
 
        for (int i = 0; i < n + 1; i++) {
            visited.Add(0);
        }
 
        // maxColors used till now are 1 as
        // all nodes are painted color 1
        int maxColors = 1;
 
        // Do a full BFS traversal from
        // all unvisited starting points
        for (int sv = 1; sv <= n; sv++) {
 
            if (visited[sv] > 0)
                continue;
 
            // If the starting point is unvisited,
            // mark it visited and push it in queue
            visited[sv] = 1;
            Queue q = new Queue();
            q.Enqueue(sv);
 
            // BFS Travel starts here
            while (q.Count != 0) {
 
                int top = (int)q.Peek();
                q.Dequeue();
 
                // Checking all adjacent nodes
                // to "top" edge in our queue
                foreach(int it in nodes[top].edges)
                {
 
                    // IMPORTANT: If the color of the
                    // adjacent node is same, increase it by
                    // 1
                    if (nodes[top].color == nodes[it].color)
                        nodes[it].color += 1;
 
                    // If number of colors used shoots m,
                    // return
                    // 0
                    maxColors = Math.Max(
                        maxColors,
                        Math.Max(nodes[top].color,
                                 nodes[it].color));
                    if (maxColors > m)
                        return 0;
 
                    // If the adjacent node is not visited,
                    // mark it visited and push it in queue
                    if (visited[it] == 0) {
                        visited[it] = 1;
                        q.Enqueue(it);
                    }
                }
            }
        }
        return 1;
    }
 
    // Driver code
    public static void Main()
    {
 
        int n = 4;
        int[, ] graph = { { 0, 1, 1, 1 },
                          { 1, 0, 1, 0 },
                          { 1, 1, 0, 1 },
                          { 1, 0, 1, 0 } };
        int m = 3; // Number of colors
 
        // Create a vector of n+1
        // nodes of type "node"
        // The zeroth position is just
        // dummy (1 to n to be used)
        List<node> nodes = new List<node>();
        for (int i = 0; i < n + 1; i++) {
            nodes.Add(new node());
        }
 
        // Add edges to each node as per given input
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (graph[i, j] > 0) {
 
                    // Connect the undirected graph
                    nodes[i].edges.Add(i);
                    nodes[j].edges.Add(j);
                }
            }
        }
 
        // Function call
        Console.WriteLine(canPaint(nodes, n, m));
    }
}
 
// This code is contributed by rutvik_56.

Javascript




<script>
 
// Javascript program for the above approach
class node
{
     
    // A node class which stores the color
    // and the edges connected to the node
    constructor()
    {
        this.color = 1;
        this.edges = new Set();
    }
};
 
function canPaint(nodes, n, m)
{
     
    // Create a visited array of n
    // nodes, initialized to zero
    var visited = [];
 
    for(var i = 0; i < n + 1; i++)
    {
        visited.push(0);
    }
 
    // maxColors used till now are 1 as
    // all nodes are painted color 1
    var maxColors = 1;
 
    // Do a full BFS traversal from
    // all unvisited starting points
    for(var sv = 1; sv <= n; sv++)
    {
        if (visited[sv] > 0)
            continue;
 
        // If the starting point is unvisited,
        // mark it visited and push it in queue
        visited[sv] = 1;
        var q = [];
        q.push(sv);
 
        // BFS Travel starts here
        while (q.length != 0)
        {
            var top = q[0];
            q.shift();
 
            // Checking all adjacent nodes
            // to "top" edge in our queue
            for(var it of nodes[top].edges)
            {
                 
                // IMPORTANT: If the color of the
                // adjacent node is same, increase it by 1
                if (nodes[top].color == nodes[it].color)
                    nodes[it].color += 1;
 
                // If number of colors used shoots m, return
                // 0
                maxColors = Math.max(maxColors, Math.max(
                                     nodes[top].color,
                                     nodes[it].color));
                if (maxColors > m)
                    return 0;
 
                // If the adjacent node is not visited,
                // mark it visited and push it in queue
                if (visited[it] == 0)
                {
                    visited[it] = 1;
                    q.push(it);
                }
            }
        }
    }
    return 1;
}
 
// Driver code
var n = 4;
var graph = [ [ 0, 1, 1, 1 ],
              [ 1, 0, 1, 0 ],
              [ 1, 1, 0, 1 ],
              [ 1, 0, 1, 0 ] ];
               
// Number of colors     
var m = 3;
 
// Create a vector of n+1
// nodes of type "node"
// The zeroth position is just
// dummy (1 to n to be used)
var nodes = [];
for(var i = 0; i < n+ 1; i++)
{
    nodes.push(new node());
}
 
// Push edges to each node as per given input
for (var i = 0; i < n; i++)
{
    for(var j = 0; j < n; j++)
    {
        if(graph[i, j] > 0)
        {
             
            // Connect the undirected graph
            nodes[i].edges.push(i);
            nodes[j].edges.push(j);
        }
    }
}
 
// Display final answer
document.write(canPaint(nodes, n, m));
 
// This code is contributed by rrrtnx
 
</script>

Output

1

Time Complexity: O(V + E)
Auxiliary Space: O(V). For Storing Visited List

Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above.


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!