Given an edges of graph and a number m, the your task is to find weather is possible to color the given graph with at most m colors such that no two adjacent vertices of the graph are colored with the same color.
Examples
Input: V = 4, edges[][] = [[0, 1], [0, 2], [0,3], [1, 3], [2, 3]], m = 3
Output: true
Explanation: Structure allows enough separation between connected vertices, so using 3 colors is sufficient to ensure no two adjacent vertices share the same color—hence, the answer is true
Input: V = 5, edges[][] = [[0, 1], [0, 2], [0, 3], [1, 2], [1, 4], [2, 3], [2, 4], [3, 4]], m = 3
Output: false
Explanation: In this graph, the vertices are highly interconnected, especially vertex 2, which connects to four others. With only 3 colors, it’s impossible to assign colors so that no two adjacent vertices share the same color, hence, the answer is false.
Approach 1: Generate all possible configurations – O((V + E)*m^V) Time and O(E+V) Space
Generate all possible configurations of length V 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.
C++ #include <bits/stdc++.h> using namespace std; bool goodcolor(vector<int> adj[], vector<int> col){ for(int i=0;i<col.size();i++){ for(auto it:adj[i]){ if(i != it && col[i] == col[it])return false; } } return true; } bool genratecolor(int i,vector<int> col, int m, vector<int> adj[]){ if(i>=col.size()){ if(goodcolor(adj, col))return true; return false; } for(int j=0;j<m;j++){ col[i] = j; if(genratecolor(i+1,col,m, adj)) return true; col[i] = -1; } return false; } bool graphColoring(int v, vector<vector<int>> &edges, int m) { vector<int> adj[v]; // Build adjacency list from edges for (auto it : edges) { adj[it[0]].push_back(it[1]); adj[it[1]].push_back(it[0]); } vector<int> color(v, -1); return genratecolor(0, color, m, adj); } int main() { int V = 4; vector<vector<int>> edges = {{0, 1}, {0, 2},{0,3}, {1, 3}, {2, 3}}; int m = 3; // Check if the graph can be colored with m colors // such that no adjacent nodes share the same color cout << (graphColoring(V, edges, m) ? "true" : "false") << endl; return 0; } import java.util.*; class GfG { static boolean goodcolor(List<Integer> adj[], int[] col) { for (int i = 0; i < col.length; i++) { for (int it : adj[i]) { if (i != it && col[i] == col[it]) return false; } } return true; } static boolean genratecolor(int i, int[] col, int m, List<Integer> adj[]) { if (i >= col.length) { if (goodcolor(adj, col)) return true; return false; } for (int j = 0; j < m; j++) { col[i] = j; if (genratecolor(i + 1, col, m, adj)) return true; col[i] = -1; } return false; } static boolean graphColoring(int v, int[][] edges, int m) { List<Integer>[] adj = new ArrayList[v]; // Build adjacency list from edges for (int i = 0; i < v; i++) { adj[i] = new ArrayList<>(); } for (int[] it : edges) { adj[it[0]].add(it[1]); adj[it[1]].add(it[0]); } int[] color = new int[v]; Arrays.fill(color, -1); return genratecolor(0, color, m, adj); } public static void main(String[] args) { int V = 4; int[][] edges = {{0, 1}, {0, 2},{0,3}, {1, 3}, {2, 3}}; int m = 3; // Check if the graph can be colored with m colors // such that no adjacent nodes share the same color System.out.println(graphColoring(V, edges, m) ? "true" : "false"); } } def goodcolor(adj, col): # Check if the coloring is valid for i in range(len(col)): for it in adj[i]: if i != it and col[i] == col[it]: return False return True def genratecolor(i, col, m, adj): if i >= len(col): if goodcolor(adj, col): return True return False for j in range(m): col[i] = j if genratecolor(i + 1, col, m, adj): return True col[i] = -1 return False def graphColoring(v, edges, m): adj = [[] for _ in range(v)] # Build adjacency list from edges for u, w in edges: adj[u].append(w) adj[w].append(u) color = [-1] * v return genratecolor(0, color, m, adj) # Test V = 4 edges = [[0, 1], [0, 2], [0,3], [1, 3], [2, 3]] m = 3 # Check if the graph can be colored with m colors # such that no adjacent nodes share the same color print("true" if graphColoring(V, edges, m) else "false") using System; using System.Collections.Generic; class GfG{ static bool goodcolor(List<int>[] adj, int[] col){ for (int i = 0; i < col.Length; i++){ foreach (int it in adj[i]){ if (i != it && col[i] == col[it]) return false; } } return true; } static bool genratecolor(int i, int[] col, int m, List<int>[] adj){ if (i >= col.Length){ if (goodcolor(adj, col)) return true; return false; } for (int j = 0; j < m; j++){ col[i] = j; if (genratecolor(i + 1, col, m, adj)) return true; col[i] = -1; } return false; } static bool graphColoring(int v, int[,] edges, int m){ List<int>[] adj = new List<int>[v]; // Build adjacency list from edges for (int i = 0; i < v; i++){ adj[i] = new List<int>(); } for (int i = 0; i < edges.GetLength(0); i++) { int u = edges[i, 0]; int v2 = edges[i, 1]; adj[u].Add(v2); adj[v2].Add(u); } int[] color = new int[v]; for (int i = 0; i < v; i++) color[i] = -1; return genratecolor(0, color, m, adj); } public static void Main(string[] args) { int V = 4; int[,] edges = {{0, 1}, {0, 2},{0,3}, {1, 3}, {2, 3}}; int m = 3; // Check if the graph can be colored with m colors // such that no adjacent nodes share the same color Console.WriteLine(graphColoring(V, edges, m) ? "true" : "false"); } } function goodcolor(adj, col) { // Check if the coloring is valid for (let i = 0; i < col.length; i++) { for (let it of adj[i]) { if (i !== it && col[i] === col[it]) return false; } } return true; } function genratecolor(i, col, m, adj) { if (i >= col.length) { if (goodcolor(adj, col)) return true; return false; } for (let j = 0; j < m; j++) { col[i] = j; if (genratecolor(i + 1, col, m, adj)) return true; col[i] = -1; } return false; } function graphColoring(v, edges, m) { let adj = Array.from({ length: v }, () => []); // Build adjacency list from edges for (let [u, w] of edges) { adj[u].push(w); adj[w].push(u); } let color = new Array(v).fill(-1); return genratecolor(0, color, m, adj); } // Test let V = 4; let edges = [[0, 1], [0, 2], [0,3], [1, 3], [2, 3]]; let m = 3; // Check if the graph can be colored with m colors // such that no adjacent nodes share the same color console.log(graphColoring(V, edges, m) ? "true" : "false"); Approach 2: Using Backtracking – O(V * m^V) Time and O(V+E) Space
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
Illustration:
C++ #include <bits/stdc++.h> using namespace std; // Function to check if it's safe to color the current vertex // with the given color bool issafe(int vertex, int col, vector<int> adj[], vector<int> &color) { for (auto it : adj[vertex]) { // If adjacent vertex has the same color, not safe if (color[it] != -1 && col == color[it]) return false; } return true; } // Recursive function to try all colorings bool cancolor(int vertex, int m, vector<int> adj[], vector<int> &color) { // If all vertices are colored successfully if (vertex == color.size()) return true; // Try all colors from 0 to m-1 for (int i = 0; i < m; i++) { if (issafe(vertex, i, adj, color)) { color[vertex] = i; if (cancolor(vertex + 1, m, adj, color)) // If the rest can be colored, return true return true; color[vertex] = -1; } } // No valid coloring found return false; } bool graphColoring(int v, vector<vector<int>> &edges, int m) { vector<int> adj[v]; // Build adjacency list from edges for (auto it : edges) { adj[it[0]].push_back(it[1]); adj[it[1]].push_back(it[0]); } vector<int> color(v, -1); return cancolor(0, m, adj, color); } int main() { int V = 4; vector<vector<int>> edges = {{0, 1}, {0, 2},{0,3}, {1, 3}, {2, 3}}; int m = 3; // Check if the graph can be colored with m colors // such that no adjacent nodes share the same color cout << (graphColoring(V, edges, m) ? "true" : "false") << endl; return 0; } import java.util.*; public class Main { // Function to check if it's safe to color the current // vertex with the given color static boolean issafe(int vertex, int col, List<Integer>[] adj, int[] color) { for (int it : adj[vertex]) { // If adjacent vertex has the same color, not safe if (color[it] != -1 && col == color[it]) return false; } return true; } // Recursive function to try all colorings static boolean cancolor(int vertex, int m, List<Integer>[] adj, int[] color) { // If all vertices are colored successfully if (vertex == color.length) return true; // Try all colors from 0 to m-1 for (int i = 0; i < m; i++) { if (issafe(vertex, i, adj, color)) { color[vertex] = i; if (cancolor(vertex + 1, m, adj, color)) // If the rest can be colored, return true return true; color[vertex] = -1; } } return false; // No valid coloring found } static boolean graphColoring(int v, int[][] edges, int m) { List<Integer>[] adj = new ArrayList[v]; for (int i = 0; i < v; i++) adj[i] = new ArrayList<>(); // Build adjacency list from edges for (int[] it : edges) { adj[it[0]].add(it[1]); adj[it[1]].add(it[0]); } int[] color = new int[v]; Arrays.fill(color, -1); return cancolor(0, m, adj, color); } public static void main(String[] args) { int V = 4; int[][] edges = {{0, 1}, {0, 2},{0,3}, {1, 3}, {2, 3}}; int m = 3; // Check if the graph can be colored with m colors // such that no adjacent nodes share the same color System.out.println(graphColoring(V, edges, m) ? "true" : "false"); } } # Function to check if it's safe to color the current vertex # with the given color def issafe(vertex, col, adj, color): for it in adj[vertex]: # If adjacent vertex has the same color, not safe if color[it] != -1 and col == color[it]: return False return True # Recursive function to try all colorings def cancolor(vertex, m, adj, color): # If all vertices are colored successfully if vertex == len(color): return True # Try all colors from 0 to m-1 for i in range(m): if issafe(vertex, i, adj, color): color[vertex] = i if cancolor(vertex + 1, m, adj, color): # If the rest can be colored, return true return True color[vertex] = -1 # Backtrack # No valid coloring found return False # Main function to set up the graph and call coloring logic def graphColoring(v, edges, m): adj = [[] for _ in range(v)] # Build adjacency list from edges for u, w in edges: adj[u].append(w) adj[w].append(u) color = [-1] * v return cancolor(0, m, adj, color) # Driver code if __name__ == "__main__": V = 4 edges = [[0, 1], [0, 2], [0,3], [1, 3], [2, 3]] m = 3 # Check if the graph can be colored with m colors # such that no adjacent nodes share the same color print("true" if graphColoring(V, edges, m) else "false") using System; using System.Collections.Generic; class GfG{ // Function to check if it's safe to color the current // vertex with the given color static bool issafe(int vertex, int col, List<int>[] adj, int[] color){ foreach (int it in adj[vertex]){ // If adjacent vertex has the same color, not safe if (color[it] != -1 && col == color[it]) return false; } return true; } // Recursive function to try all colorings static bool cancolor(int vertex, int m, List<int>[] adj, int[] color){ // If all vertices are colored successfully if (vertex == color.Length) return true; // Try all colors from 0 to m-1 for (int i = 0; i < m; i++){ if (issafe(vertex, i, adj, color)){ color[vertex] = i; if (cancolor(vertex + 1, m, adj, color)) // If the rest can be colored, return true return true; color[vertex] = -1; } } return false; // No valid coloring found } static bool graphColoring(int v, int[,] edges, int m){ List<int>[] adj = new List<int>[v]; for (int i = 0; i < v; i++) adj[i] = new List<int>(); // Build adjacency list from edges for (int i = 0; i < edges.GetLength(0); i++){ int u = edges[i, 0]; int v2 = edges[i, 1]; adj[u].Add(v2); adj[v2].Add(u); } int[] color = new int[v]; for (int i = 0; i < v; i++) color[i] = -1; return cancolor(0, m, adj, color); } static void Main(string[] args){ int V = 4; int[,] edges = {{0, 1}, {0, 2},{0,3}, {1, 3}, {2, 3}}; int m = 3; // Check if the graph can be colored with m colors // such that no adjacent nodes share the same color Console.WriteLine(graphColoring(V, edges, m) ? "true" : "false"); } } // Function to check if it's safe to color the current vertex // with the given color function issafe(vertex, col, adj, color) { for (let it of adj[vertex]) { // If adjacent vertex has the same color, not safe if (color[it] !== -1 && col === color[it]) return false; } return true; } // Recursive function to try all colorings function cancolor(vertex, m, adj, color) { // If all vertices are colored successfully if (vertex === color.length) return true; // Try all colors from 0 to m-1 for (let i = 0; i < m; i++) { if (issafe(vertex, i, adj, color)) { color[vertex] = i; if (cancolor(vertex + 1, m, adj, color)) // If the rest can be colored, return true return true; color[vertex] = -1; } } // No valid coloring found return false; } // Main function to set up the graph and call coloring logic function graphColoring(v, edges, m) { let adj = new Array(v).fill(0).map(() => []); // Build adjacency list from edges for (let [u, w] of edges) { adj[u].push(w); adj[w].push(u); } let color = new Array(v).fill(-1); return cancolor(0, m, adj, color); } // Driver code const V = 4; const edges = [[0, 1], [0, 2], [0,3], [1, 3], [2, 3]]; const m = 3; // Check if the graph can be colored with m colors // such that no adjacent nodes share the same color console.log(graphColoring(V, edges, m) ? "true" : "false"); Time Complexity: O(V * mV). There is a total of O(mV) combinations of colors. For each attempted coloring of a vertex you call issafe(), can have up to V–1 neighbors, so issafe() is O(V)
Auxiliary Space: O(V + E). The recursive Stack of the graph coloring function will require O(V) space, Adjacency list and color array will required O(V+E).
Similar Reads
Depth First Search or DFS for a Graph
In Depth First Search (or DFS) for a graph, we traverse all adjacent vertices one by one. When we traverse an adjacent vertex, we completely finish the traversal of all vertices reachable through that adjacent vertex. This is similar to a tree, where we first completely traverse the left subtree and
13 min read
DFS in different language
Iterative Depth First Traversal of Graph
Given a directed Graph, the task is to perform Depth First Search of the given graph. Note: Start DFS from node 0, and traverse the nodes in the same order as adjacency list. Note : There can be multiple DFS traversals of a graph according to the order in which we pick adjacent vertices. Here we pic
10 min read
Applications, Advantages and Disadvantages of Depth First Search (DFS)
Depth First Search is a widely used algorithm for traversing a graph. Here we have discussed some applications, advantages, and disadvantages of the algorithm. Applications of Depth First Search:1. Detecting cycle in a graph: A graph has a cycle if and only if we see a back edge during DFS. So we ca
4 min read
Difference between BFS and DFS
Breadth-First Search (BFS) and Depth-First Search (DFS) are two fundamental algorithms used for traversing or searching graphs and trees. This article covers the basic difference between Breadth-First Search and Depth-First Search. ParametersBFSDFSStands forBFS stands for Breadth First Search.DFS st
2 min read
Depth First Search or DFS for disconnected Graph
Given a Disconnected Graph, the task is to implement DFS or Depth First Search Algorithm for this Disconnected Graph. Example: Input: Output: 0 1 2 3 Algorithm for DFS on Disconnected Graph:In the post for Depth First Search for Graph, only the vertices reachable from a given source vertex can be vi
7 min read
Printing pre and post visited times in DFS of a graph
Depth First Search (DFS) marks all the vertices of a graph as visited. So for making DFS useful, some additional information can also be stored. For instance, the order in which the vertices are visited while running DFS. Pre-visit and Post-visit numbers are the extra information that can be stored
8 min read
Tree, Back, Edge and Cross Edges in DFS of Graph
Given a directed graph, the task is to identify tree, forward, back and cross edges present in the graph. Note: There can be multiple answers. Example: Input: Graph Output:Tree Edges: 1->2, 2->4, 4->6, 1->3, 3->5, 5->7, 5->8 Forward Edges: 1->8 Back Edges: 6->2 Cross Edges
9 min read
Transitive Closure of a Graph using DFS
Given a directed graph, find out if a vertex v is reachable from another vertex u for all vertex pairs (u, v) in the given graph. Here reachable means that there is a path from vertex u to v. The reach-ability matrix is called transitive closure of a graph. For example, consider below graph: Transit
8 min read
Variations of DFS implementations