# Graph Coloring | Set 2 (Greedy Algorithm)

We introduced graph coloring and applications in previous post. As discussed in the previous post, graph coloring is widely used. Unfortunately, there is no efficient algorithm available for coloring a graph with minimum number of colors as the problem is a known NP Complete problem. There are approximate algorithms to solve the problem though. Following is the basic Greedy Algorithm to assign colors. It doesn’t guarantee to use minimum colors, but it guarantees an upper bound on the number of colors. The basic algorithm never uses more than d+1 colors where d is the maximum degree of a vertex in the given graph.

**Basic Greedy Coloring Algorithm:**

1.Color first vertex with first color.

2.Do following for remaining V-1 vertices.

…..a)Consider the currently picked vertex and color it with the

lowest numbered color that has not been used on any previously

colored vertices adjacent to it. If all previously used colors

appear on vertices adjacent to v, assign a new color to it.

Following are C++ and Java implementations of the above Greedy Algorithm.

## C++

`// A C++ program to implement greedy algorithm for graph coloring ` `#include <iostream> ` `#include <list> ` `using` `namespace` `std; ` ` ` `// A class that represents an undirected graph ` `class` `Graph ` `{ ` ` ` `int` `V; ` `// No. of vertices ` ` ` `list<` `int` `> *adj; ` `// A dynamic array of adjacency lists ` `public` `: ` ` ` `// Constructor and destructor ` ` ` `Graph(` `int` `V) { ` `this` `->V = V; adj = ` `new` `list<` `int` `>[V]; } ` ` ` `~Graph() { ` `delete` `[] adj; } ` ` ` ` ` `// function to add an edge to graph ` ` ` `void` `addEdge(` `int` `v, ` `int` `w); ` ` ` ` ` `// Prints greedy coloring of the vertices ` ` ` `void` `greedyColoring(); ` `}; ` ` ` `void` `Graph::addEdge(` `int` `v, ` `int` `w) ` `{ ` ` ` `adj[v].push_back(w); ` ` ` `adj[w].push_back(v); ` `// Note: the graph is undirected ` `} ` ` ` `// Assigns colors (starting from 0) to all vertices and prints ` `// the assignment of colors ` `void` `Graph::greedyColoring() ` `{ ` ` ` `int` `result[V]; ` ` ` ` ` `// Assign the first color to first vertex ` ` ` `result[0] = 0; ` ` ` ` ` `// Initialize remaining V-1 vertices as unassigned ` ` ` `for` `(` `int` `u = 1; u < V; u++) ` ` ` `result[u] = -1; ` `// no color is assigned to u ` ` ` ` ` `// A temporary array to store the available colors. True ` ` ` `// value of available[cr] would mean that the color cr is ` ` ` `// assigned to one of its adjacent vertices ` ` ` `bool` `available[V]; ` ` ` `for` `(` `int` `cr = 0; cr < V; cr++) ` ` ` `available[cr] = ` `false` `; ` ` ` ` ` `// Assign colors to remaining V-1 vertices ` ` ` `for` `(` `int` `u = 1; u < V; u++) ` ` ` `{ ` ` ` `// Process all adjacent vertices and flag their colors ` ` ` `// as unavailable ` ` ` `list<` `int` `>::iterator i; ` ` ` `for` `(i = adj[u].begin(); i != adj[u].end(); ++i) ` ` ` `if` `(result[*i] != -1) ` ` ` `available[result[*i]] = ` `true` `; ` ` ` ` ` `// Find the first available color ` ` ` `int` `cr; ` ` ` `for` `(cr = 0; cr < V; cr++) ` ` ` `if` `(available[cr] == ` `false` `) ` ` ` `break` `; ` ` ` ` ` `result[u] = cr; ` `// Assign the found color ` ` ` ` ` `// Reset the values back to false for the next iteration ` ` ` `for` `(i = adj[u].begin(); i != adj[u].end(); ++i) ` ` ` `if` `(result[*i] != -1) ` ` ` `available[result[*i]] = ` `false` `; ` ` ` `} ` ` ` ` ` `// print the result ` ` ` `for` `(` `int` `u = 0; u < V; u++) ` ` ` `cout << ` `"Vertex "` `<< u << ` `" ---> Color "` ` ` `<< result[u] << endl; ` `} ` ` ` `// Driver program to test above function ` `int` `main() ` `{ ` ` ` `Graph g1(5); ` ` ` `g1.addEdge(0, 1); ` ` ` `g1.addEdge(0, 2); ` ` ` `g1.addEdge(1, 2); ` ` ` `g1.addEdge(1, 3); ` ` ` `g1.addEdge(2, 3); ` ` ` `g1.addEdge(3, 4); ` ` ` `cout << ` `"Coloring of graph 1 \n"` `; ` ` ` `g1.greedyColoring(); ` ` ` ` ` `Graph g2(5); ` ` ` `g2.addEdge(0, 1); ` ` ` `g2.addEdge(0, 2); ` ` ` `g2.addEdge(1, 2); ` ` ` `g2.addEdge(1, 4); ` ` ` `g2.addEdge(2, 4); ` ` ` `g2.addEdge(4, 3); ` ` ` `cout << ` `"\nColoring of graph 2 \n"` `; ` ` ` `g2.greedyColoring(); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// A Java program to implement greedy algorithm for graph coloring ` `import` `java.io.*; ` `import` `java.util.*; ` `import` `java.util.LinkedList; ` ` ` `// This class represents an undirected graph using adjacency list ` `class` `Graph ` `{ ` ` ` `private` `int` `V; ` `// No. of vertices ` ` ` `private` `LinkedList<Integer> adj[]; ` `//Adjacency List ` ` ` ` ` `//Constructor ` ` ` `Graph(` `int` `v) ` ` ` `{ ` ` ` `V = v; ` ` ` `adj = ` `new` `LinkedList[v]; ` ` ` `for` `(` `int` `i=` `0` `; i<v; ++i) ` ` ` `adj[i] = ` `new` `LinkedList(); ` ` ` `} ` ` ` ` ` `//Function to add an edge into the graph ` ` ` `void` `addEdge(` `int` `v,` `int` `w) ` ` ` `{ ` ` ` `adj[v].add(w); ` ` ` `adj[w].add(v); ` `//Graph is undirected ` ` ` `} ` ` ` ` ` `// Assigns colors (starting from 0) to all vertices and ` ` ` `// prints the assignment of colors ` ` ` `void` `greedyColoring() ` ` ` `{ ` ` ` `int` `result[] = ` `new` `int` `[V]; ` ` ` ` ` `// Initialize all vertices as unassigned ` ` ` `Arrays.fill(result, -` `1` `); ` ` ` ` ` `// Assign the first color to first vertex ` ` ` `result[` `0` `] = ` `0` `; ` ` ` ` ` `// A temporary array to store the available colors. False ` ` ` `// value of available[cr] would mean that the color cr is ` ` ` `// assigned to one of its adjacent vertices ` ` ` `boolean` `available[] = ` `new` `boolean` `[V]; ` ` ` ` ` `// Initially, all colors are available ` ` ` `Arrays.fill(available, ` `true` `); ` ` ` ` ` `// Assign colors to remaining V-1 vertices ` ` ` `for` `(` `int` `u = ` `1` `; u < V; u++) ` ` ` `{ ` ` ` `// Process all adjacent vertices and flag their colors ` ` ` `// as unavailable ` ` ` `Iterator<Integer> it = adj[u].iterator() ; ` ` ` `while` `(it.hasNext()) ` ` ` `{ ` ` ` `int` `i = it.next(); ` ` ` `if` `(result[i] != -` `1` `) ` ` ` `available[result[i]] = ` `false` `; ` ` ` `} ` ` ` ` ` `// Find the first available color ` ` ` `int` `cr; ` ` ` `for` `(cr = ` `0` `; cr < V; cr++){ ` ` ` `if` `(available[cr]) ` ` ` `break` `; ` ` ` `} ` ` ` ` ` `result[u] = cr; ` `// Assign the found color ` ` ` ` ` `// Reset the values back to true for the next iteration ` ` ` `Arrays.fill(available, ` `true` `); ` ` ` `} ` ` ` ` ` `// print the result ` ` ` `for` `(` `int` `u = ` `0` `; u < V; u++) ` ` ` `System.out.println(` `"Vertex "` `+ u + ` `" ---> Color "` ` ` `+ result[u]); ` ` ` `} ` ` ` ` ` `// Driver method ` ` ` `public` `static` `void` `main(String args[]) ` ` ` `{ ` ` ` `Graph g1 = ` `new` `Graph(` `5` `); ` ` ` `g1.addEdge(` `0` `, ` `1` `); ` ` ` `g1.addEdge(` `0` `, ` `2` `); ` ` ` `g1.addEdge(` `1` `, ` `2` `); ` ` ` `g1.addEdge(` `1` `, ` `3` `); ` ` ` `g1.addEdge(` `2` `, ` `3` `); ` ` ` `g1.addEdge(` `3` `, ` `4` `); ` ` ` `System.out.println(` `"Coloring of graph 1"` `); ` ` ` `g1.greedyColoring(); ` ` ` ` ` `System.out.println(); ` ` ` `Graph g2 = ` `new` `Graph(` `5` `); ` ` ` `g2.addEdge(` `0` `, ` `1` `); ` ` ` `g2.addEdge(` `0` `, ` `2` `); ` ` ` `g2.addEdge(` `1` `, ` `2` `); ` ` ` `g2.addEdge(` `1` `, ` `4` `); ` ` ` `g2.addEdge(` `2` `, ` `4` `); ` ` ` `g2.addEdge(` `4` `, ` `3` `); ` ` ` `System.out.println(` `"Coloring of graph 2 "` `); ` ` ` `g2.greedyColoring(); ` ` ` `} ` `} ` `// This code is contributed by Aakash Hasija ` |

*chevron_right*

*filter_none*

Output:

Coloring of graph 1 Vertex 0 ---> Color 0 Vertex 1 ---> Color 1 Vertex 2 ---> Color 2 Vertex 3 ---> Color 0 Vertex 4 ---> Color 1 Coloring of graph 2 Vertex 0 ---> Color 0 Vertex 1 ---> Color 1 Vertex 2 ---> Color 2 Vertex 3 ---> Color 0 Vertex 4 ---> Color 3

Time Complexity: O(V^2 + E) in worst case.

**Analysis of Basic Algorithm**

The above algorithm doesn’t always use minimum number of colors. Also, the number of colors used sometime depend on the order in which vertices are processed. For example, consider the following two graphs. Note that in graph on right side, vertices 3 and 4 are swapped. If we consider the vertices 0, 1, 2, 3, 4 in left graph, we can color the graph using 3 colors. But if we consider the vertices 0, 1, 2, 3, 4 in right graph, we need 4 colors.

So the order in which the vertices are picked is important. Many people have suggested different ways to find an ordering that work better than the basic algorithm on average. The most common is Welsh–Powell Algorithm which considers vertices in descending order of degrees.

**How does the basic algorithm guarantee an upper bound of d+1?**

Here d is the maximum degree in the given graph. Since d is maximum degree, a vertex cannot be attached to more than d vertices. When we color a vertex, at most d colors could have already been used by its adjacent. To color this vertex, we need to pick the smallest numbered color that is not used by the adjacent vertices. If colors are numbered like 1, 2, …., then the value of such smallest number must be between 1 to d+1 (Note that d numbers are already picked by adjacent vertices).

This can also be proved using induction. See this video lecture for proof.

We will soon be discussing some interesting facts about chromatic number and graph coloring.

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

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

## Recommended Posts:

- Coloring a Cycle Graph
- Edge Coloring of a Graph
- Graph Coloring | Set 1 (Introduction and Applications)
- Mathematics | Planar Graphs and Graph Coloring
- Boruvka's algorithm | Greedy Algo-9
- Greedy Algorithm for Egyptian Fraction
- Set Cover Problem | Set 1 (Greedy Approximate Algorithm)
- K Centers Problem | Set 1 (Greedy Approximate Algorithm)
- Greedy Algorithm to find Minimum number of Coins
- Dijkstra's shortest path algorithm | Greedy Algo-7
- Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2
- Dijkstra’s Algorithm for Adjacency List Representation | Greedy Algo-8
- Minimum number of subsequences required to convert one string to another using Greedy Algorithm
- Hierholzer's Algorithm for directed graph
- Welsh Powell Graph colouring Algorithm
- Why Prim’s and Kruskal's MST algorithm fails for Directed Graph?
- Shortest path in a directed graph by Dijkstra’s algorithm
- Find if a degree sequence can form a simple graph | Havel-Hakimi Algorithm
- m Coloring Problem | Backtracking-5
- Convert the undirected graph into directed graph such that there is no path of length greater than 1