# m Coloring Problem | Backtracking-5

• Difficulty Level : Medium
• Last Updated : 28 Apr, 2022

Given an undirected graph and a number m, determine if the graph can be coloured with at most m colours such that no two adjacent vertices of the graph are colored with the same color. Here coloring of a graph means the assignment of colors to all vertices.

Input-Output format:

Input:

1. A 2D array graph[V][V] where V is the number of vertices in graph and graph[V][V] is an adjacency matrix representation of the graph. A value graph[i][j] is 1 if there is a direct edge from i to j, otherwise graph[i][j] is 0.
2. An integer m is the maximum number of colors that can be used.

Output:
An array color[V] that should have numbers from 1 to m. color[i] should represent the color assigned to the ith vertex. The code should also return false if the graph cannot be colored with m colors.

Example:

```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
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.```

Following is an example of a graph that can be coloured with 3 different colours. ## We strongly recommend that you click here and practice it, before moving on to the solution.

Method 1: Naive.

Naive Approach: Generate all possible configurations of colors. Since each node can be coloured using any of the m available colours, the total number of colour configurations possible are m^V.
After generating a configuration of colour, check if the adjacent vertices have the same colour or not. If the conditions are met, print the combination and break the loop.

Algorithm:

1. Create a recursive function that takes current index, number of vertices and output color array.
2. 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.
3. Assign a color to a vertex (1 to m).
4. For every assigned color recursively call the function with next index and number of vertices
5. If any recursive function returns true break the loop and returns true.

Below is the implementation of the above idea:

## C++

 `#include` `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;`   `    ``if` `(!graphColoring(graph, m, 0, color))` `        ``cout << ``"Solution does not exist"``;`   `    ``return` `0;` `}`   `// This code is contributed by shivanisinghss2110`

## C

 `#include ` `#include `   `// 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 program to test above function` `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;`   `    ``if` `(!graphColoring(graph, m, 0, color))` `        ``printf``(``"Solution does not exist"``);`   `    ``return` `0;` `}`

## Java

 `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``;` `    ``if` `(!graphColoring(graph, m, ``0``, color))` `      ``System.out.println(``"Solution does not exist"``);` `  ``}` `}`   `// This code is contributed by divyeh072019.`

## Python3

 `# 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``)]`   `    ``if` `(``not` `graphColoring(graph, m, ``0``, color)):` `        ``print` `(``"Solution does not exist"``)`   `# This code is contributed by mohit kumar 29`

## C#

 `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;` ` `  `    ``if` `(!graphColoring(graph, m, 0, color))` `        ``Console.WriteLine(``"Solution does not exist"``);` `  ``}` `}`   `// this code is contributed by divyeshrabadiya07.`

## Javascript

 ``

Output

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

Complexity Analysis:

• Time Complexity: O(m^V).
There is a total O(m^V) combination of colors. So the time complexity is O(m^V).
• Space Complexity: O(V).
Recursive Stack of graphColoring(…) function will require O(V) space.

Method 2: Backtracking.

Approach: The idea is to assign colors one by one to different vertices, starting from the 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.

Algorithm:

1. Create a recursive function that takes the graph, current index, number of vertices, and output color array.
2. If the current index is equal to the number of vertices. Print the color configuration in output array.
3. Assign a color to a vertex (1 to m).
4. 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 next index and number of vertices
5. If any recursive function returns true break the loop and return true.
6. If no recursive function returns true then return false.

Below is the implementation of the above idea:

## C++

 `// C++ program for solution of M ` `// Coloring problem using backtracking ` `#include ` `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; ` `    ``graphColoring(graph, m);` `    ``return` `0;` `}`   `// This code is contributed by Shivani`

## C

 `#include ` `#include `   `// 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 program to test above function` `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` `    ``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 program to test above function` `    ``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` `        ``Coloring.graphColoring(graph, m);` `    ``}` `}` `// This code is contributed by Abhishek Shankhadhar`

## Python3

 `# Python 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` `g ``=` `Graph(``4``)` `g.graph ``=` `[[``0``, ``1``, ``1``, ``1``], [``1``, ``0``, ``1``, ``0``], [``1``, ``1``, ``0``, ``1``], [``1``, ``0``, ``1``, ``0``]]` `m ``=` `3` `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` `        ``Coloring.graphColoring(graph, m);` `    ``}` `}`   `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output

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

Complexity Analysis:

• Time Complexity: O(m^V).
There are total O(m^V) combination of colors. So time complexity is O(m^V). The upperbound time complexity remains the same but the average time taken will be less.
• Space Complexity: O(V).
Recursive Stack of graphColoring(…) function will require O(V) space.

Method 3:  Using BFS

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

• 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 same, increase the color of the other node (not the current) by one.
• check if it visited or unvisited. If not visited, mark it as visited and push it in 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 travelling).

## C++

 `// CPP program for the above approach` `#include ` `#include ` `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& 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 nodes(n + 1);`   `      ``// Add edges to each node as per given input` `      ``for` `(``int` `i = 0; i < n; i++) ` `      ``{` `         ``for``(``int` `j =0;j

## 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 edges = ``new` `HashSet();` `}` `class` `GFG ` `{` `    ``static` `int` `canPaint(ArrayList nodes, ``int` `n, ``int` `m)` `    ``{` `      `  `        ``// Create a visited array of n` `        ``// nodes, initialized to zero` `        ``ArrayList visited = ``new` `ArrayList();` `        ``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 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 nodes = ``new` `ArrayList();` `        `  `        ``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);` `             ``}` `         ``}` `      ``}` `      `  `      ``// Display final answer` `        ``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(__)`   `    ``# Display final answer` `    ``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 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 nodes = ``new` `List();` `      ``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);` `              ``}` `         ``}` `      ``}`   `        ``// Display final answer` `        ``Console.WriteLine(canPaint(nodes, n, m));` `   ``}` `}`     `// This code is contributed by rutvik_56.`

## Javascript

 ``

Output

`1`

Complexity Analysis:

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

References:
http://en.wikipedia.org/wiki/Graph_coloring