Related Articles

# Minimum colors required such that edges forming cycle do not have same color

• Difficulty Level : Expert
• Last Updated : 31 May, 2021

Given a directed graph with V vertices and E edges without self-loops and multiple edges, the task is to find the minimum number of colors required such that edges of the same color do not form cycle and also find the colors for every edge.
Examples:

Input: V = {1, 2, 3}, E = {(1, 2), (2, 3), (3, 1)}
Output:
1 1 2 Explanation:
In the above given graph it forms only one cycle,
that is Vertices connecting 1, 2, 3 forms a cycle
Then the edges connecting 1->2 or 2->3 or 3->1 can be colored
with a different color such that edges forming cycle don’t have same color
Input: V = {1, 2, 3, 4, 5}, E = {(1, 2), (1, 3), (2, 3), (2, 4), (3, 4), (4, 5), (5, 3)}
Output:
Colors of Edges – 1 1 1 1 1 1 2
Explanation:
In the above given graph it forms only one cycle,
that is Vertices connecting 3, 4, 5 forms a cycle
Then the edges connecting 5->3 or 4->5 or 3->4 can be colored
with a different color such that edges forming cycle don’t have same color
Final Colors of the Edges –
{1: 1, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1, 7: 2}
The above array denotes the pairs as – Edge : Color Code

Approach: The idea is to find the cycle in the graph, which can be done with the help of DFS for the Graph in which when a node which is already visited is visited again with a new edge, then that edges is colored with another color else if there is no cycle then all edges can be colored with only one color.
Algorithm:

• Mark every edges with color 1 and every vertices as unvisited.
• Traverse the graph using the DFS Traversal for the graph and mark the nodes visited.
• When a node which is visited already, then the edge connecting the vertex is marked to be colored with color 2.
• Print the colors of the edges when all the vertices are visited.

Explanation with Example:
Detailed Dry-run of the Example 1

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the``// minimum colors required to``// such that edges forming cycle``// don't have same color` `#include ``using` `namespace` `std;` `const` `int` `n = 5, m = 7;` `// Variable to store the graph``vector > g[m];` `// To store that the``// vertex is visited or not``int` `col[n];` `// Boolean Value to store that``// graph contains cycle or not``bool` `cyc;` `// Variable to store the color``// of the edges of the graph``int` `res[m];` `// Function to traverse graph``// using DFS Traversal``void` `dfs(``int` `v)``{``    ``col[v] = 1;``    ` `    ``// Loop to iterate for all``    ``// edges from the source vertex``    ``for` `(``auto` `p : g[v]) {``        ``int` `to = p.first, id = p.second;``        ` `        ``// If the vertex is not visited``        ``if` `(col[to] == 0)``        ``{``            ``dfs(to);``            ``res[id] = 1;``        ``}``        ` `        ``// Condition to check cross and``        ``// forward edges of the graph``        ``else` `if` `(col[to] == 2)``        ``{``            ``res[id] = 1;``        ``}``        ` `        ``// Presence of Back Edge``        ``else` `{``            ``res[id] = 2;``            ``cyc = ``true``;``        ``}``    ``}``    ``col[v] = 2;``}` `// Driver Code``int` `main()``{``    ``g.push_back(make_pair(1, 0));``    ``g.push_back(make_pair(2, 1));``    ``g.push_back(make_pair(2, 2));``    ``g.push_back(make_pair(3, 3));``    ``g.push_back(make_pair(3, 4));``    ``g.push_back(make_pair(4, 5));``    ``g.push_back(make_pair(2, 6));``    ` `    ``// Loop to run DFS Traversal on``    ``// vertex which is not visited``    ``for` `(``int` `i = 0; i < n; ++i) {``        ``if` `(col[i] == 0)``        ``{``            ``dfs(i);``        ``}``    ``}``    ``cout << (cyc ? 2 : 1) << endl;``    ` `    ``// Loop to print the``    ``// colors of the edges``    ``for` `(``int` `i = 0; i < m; ++i) {``        ``cout << res[i] << ``' '``;``    ``}``    ``return` `0;``}`

## Java

 `// Java implementation to find the``// minimum colors required to``// such that edges forming cycle``// don't have same color``import` `java.util.*;` `class` `GFG{`` ` `static` `int` `n = ``5``, m = ``7``;``static` `class` `pair``{``    ``int` `first, second;``    ``public` `pair(``int` `first, ``int` `second) ``    ``{``        ``this``.first = first;``        ``this``.second = second;``    ``}   ``}` `// Variable to store the graph``static` `Vector []g = ``new` `Vector[m];`` ` `// To store that the``// vertex is visited or not``static` `int` `[]col = ``new` `int``[n];`` ` `// Boolean Value to store that``// graph contains cycle or not``static` `boolean` `cyc;`` ` `// Variable to store the color``// of the edges of the graph``static` `int` `[]res = ``new` `int``[m];`` ` `// Function to traverse graph``// using DFS Traversal``static` `void` `dfs(``int` `v)``{``    ``col[v] = ``1``;``     ` `    ``// Loop to iterate for all``    ``// edges from the source vertex``    ``for` `(pair  p : g[v]) {``        ``int` `to = p.first, id = p.second;``         ` `        ``// If the vertex is not visited``        ``if` `(col[to] == ``0``)``        ``{``            ``dfs(to);``            ``res[id] = ``1``;``        ``}``         ` `        ``// Condition to check cross and``        ``// forward edges of the graph``        ``else` `if` `(col[to] == ``2``)``        ``{``            ``res[id] = ``1``;``        ``}``         ` `        ``// Presence of Back Edge``        ``else` `{``            ``res[id] = ``2``;``            ``cyc = ``true``;``        ``}``    ``}``    ``col[v] = ``2``;``}`` ` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``for``(``int` `i= ``0``; i < m; i++)``        ``g[i] = ``new` `Vector();``    ``g[``0``].add(``new` `pair(``1``, ``0``));``    ``g[``0``].add(``new` `pair(``2``, ``1``));``    ``g[``1``].add(``new` `pair(``2``, ``2``));``    ``g[``1``].add(``new` `pair(``3``, ``3``));``    ``g[``2``].add(``new` `pair(``3``, ``4``));``    ``g[``3``].add(``new` `pair(``4``, ``5``));``    ``g[``4``].add(``new` `pair(``2``, ``6``));``     ` `    ``// Loop to run DFS Traversal on``    ``// vertex which is not visited``    ``for` `(``int` `i = ``0``; i < n; ++i) {``        ``if` `(col[i] == ``0``)``        ``{``            ``dfs(i);``        ``}``    ``}``    ``System.out.print((cyc ? ``2` `: ``1``) +``"\n"``);``     ` `    ``// Loop to print the``    ``// colors of the edges``    ``for` `(``int` `i = ``0``; i < m; ++i) {``        ``System.out.print(res[i] +``" "``);``    ``}``}``}` `// This code is contributed by sapnasingh4991`

## Python3

 `# Python3 implementation to find the``# minimum colors required to``# such that edges forming cycle``# don't have same color`` ` `n ``=` `5``m ``=` `7``;`` ` `# Variable to store the graph``g ``=` `[[] ``for` `i ``in` `range``(m)]`` ` `# To store that the``# vertex is visited or not``col ``=` `[``0` `for` `i ``in` `range``(n)];`` ` `# Boolean Value to store that``# graph contains cycle or not``cyc ``=` `True`` ` `# Variable to store the color``# of the edges of the graph``res ``=` `[``0` `for` `i ``in` `range``(m)];`` ` `# Function to traverse graph``# using DFS Traversal``def` `dfs(v):` `    ``col[v] ``=` `1``;``     ` `    ``# Loop to iterate for all``    ``# edges from the source vertex``    ``for` `p ``in` `g[v]:``        ` `        ``to ``=` `p[``0``]``        ``id` `=` `p[``1``];``         ` `        ``# If the vertex is not visited``        ``if` `(col[to] ``=``=` `0``):``        ` `            ``dfs(to);``            ``res[``id``] ``=` `1``;``        ` `        ``# Condition to check cross and``        ``# forward edges of the graph``        ``elif` `(col[to] ``=``=` `2``):``        ` `            ``res[``id``] ``=` `1``;``         ` `        ``# Presence of Back Edge``        ``else``:``            ``res[``id``] ``=` `2``;``            ``cyc ``=` `True``;` `    ``col[v] ``=` `2``;` `# Driver Code``if` `__name__``=``=``'__main__'``:``    ` `    ``g[``0``].append([``1``, ``0``]);``    ``g[``0``].append([``2``, ``1``]);``    ``g[``1``].append([``2``, ``2``]);``    ``g[``1``].append([``3``, ``3``]);``    ``g[``2``].append([``3``, ``4``]);``    ``g[``3``].append([``4``, ``5``]);``    ``g[``4``].append([``2``, ``6``]);``     ` `    ``# Loop to run DFS Traversal on``    ``# vertex which is not visited``    ``for` `i ``in` `range``(n):``    ` `        ``if` `(col[i] ``=``=` `0``):``        ` `            ``dfs(i);``        ` `    ``print``(``2` `if` `cyc ``else` `1``)``     ` `    ``# Loop to print the``    ``# colors of the edges``    ``for` `i ``in` `range``(m):``        ``print``(res[i], end``=``' '``)`` ` `# This code is contributed by rutvik_56`

## C#

 `// C# implementation to find the``// minimum colors required to``// such that edges forming cycle``// don't have same color``using` `System;``using` `System.Collections.Generic;` `class` `GFG{``  ` `static` `int` `n = 5, m = 7;``class` `pair``{``    ``public` `int` `first, second;``    ``public` `pair(``int` `first, ``int` `second) ``    ``{``        ``this``.first = first;``        ``this``.second = second;``    ``}   ``}`` ` `// Variable to store the graph``static` `List []g = ``new` `List[m];``  ` `// To store that the``// vertex is visited or not``static` `int` `[]col = ``new` `int``[n];``  ` `// Boolean Value to store that``// graph contains cycle or not``static` `bool` `cyc;``  ` `// Variable to store the color``// of the edges of the graph``static` `int` `[]res = ``new` `int``[m];``  ` `// Function to traverse graph``// using DFS Traversal``static` `void` `dfs(``int` `v)``{``    ``col[v] = 1;``      ` `    ``// Loop to iterate for all``    ``// edges from the source vertex``    ``foreach` `(pair  p ``in` `g[v]) {``        ``int` `to = p.first, id = p.second;``          ` `        ``// If the vertex is not visited``        ``if` `(col[to] == 0)``        ``{``            ``dfs(to);``            ``res[id] = 1;``        ``}``          ` `        ``// Condition to check cross and``        ``// forward edges of the graph``        ``else` `if` `(col[to] == 2)``        ``{``            ``res[id] = 1;``        ``}``          ` `        ``// Presence of Back Edge``        ``else` `{``            ``res[id] = 2;``            ``cyc = ``true``;``        ``}``    ``}``    ``col[v] = 2;``}``  ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``for``(``int` `i= 0; i < m; i++)``        ``g[i] = ``new` `List();``    ``g.Add(``new` `pair(1, 0));``    ``g.Add(``new` `pair(2, 1));``    ``g.Add(``new` `pair(2, 2));``    ``g.Add(``new` `pair(3, 3));``    ``g.Add(``new` `pair(3, 4));``    ``g.Add(``new` `pair(4, 5));``    ``g.Add(``new` `pair(2, 6));``      ` `    ``// Loop to run DFS Traversal on``    ``// vertex which is not visited``    ``for` `(``int` `i = 0; i < n; ++i) {``        ``if` `(col[i] == 0)``        ``{``            ``dfs(i);``        ``}``    ``}``    ``Console.Write((cyc ? 2 : 1) +``"\n"``);``      ` `    ``// Loop to print the``    ``// colors of the edges``    ``for` `(``int` `i = 0; i < m; ++i) {``        ``Console.Write(res[i] +``" "``);``    ``}``}``}`` ` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``
Output:
```2
1 1 1 1 1 1 2```

Performance Analysis:

• Time Complexity: As in the above approach, there is DFS Traversal of the graph which takes O(V + E) time, where V denotes the number of vertices and E denotes the number of edges. Hence the Time Complexity will be O(V + E).
• Auxiliary Space: O(1).

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up