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

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: 2 
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: 2 
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 

Current Vertex	Current Edge	Visited Vertices	Colors of Edges	Comments
1	1–>2	{1}	{1: 1, 2: 1, 3: 1}	Node 1 is marked as visited and Calling DFS for node 2
2	2–>3	{1, 2}	{1: 1, 2: 1, 3: 1}	Node 2 is marked as visited and Calling DFS for node 3
3	3–>1	{1, 2}	{1: 1, 2: 1, 3: 2}	As 1 is already Visited color of Edge 3 is changed to 2

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 <bits/stdc++.h>
using namespace std;

const int n = 5, m = 7;

// Variable to store the graph
vector<pair<int, int> > 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[0].push_back(make_pair(1, 0));
    g[0].push_back(make_pair(2, 1));
    g[1].push_back(make_pair(2, 2));
    g[1].push_back(make_pair(3, 3));
    g[2].push_back(make_pair(3, 4));
    g[3].push_back(make_pair(4, 5));
    g[4].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<pair > []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<pair>();
    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<pair> []g = new List<pair>[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<pair>();
    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);
        }
    }
    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

<script>
// C++ implementation to find the
// minimum colors required to
// such that edges forming cycle
// don't have same color

const n = 5, m = 7;

// Variable to store the graph
let g = new Array();

for(let i = 0;  i<m; i++){
    g.push([])
}

// To store that the
// vertex is visited or not
let col = new Array(n).fill(0);

// Boolean Value to store that
// graph contains cycle or not
let cyc;

// Variable to store the color
// of the edges of the graph
let res = new Array(m);

// Function to traverse graph
// using DFS Traversal
function dfs(v)
{
    col[v] = 1;

    // Loop to iterate for all
    // edges from the source vertex
    for (let p of g[v]) {
        let to = p[0]
        let 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
        else if (col[to] == 2)
        {
            res[id] = 1;
        }

        // Presence of Back Edge
        else {
            res[id] = 2;
            cyc = true;
        }
    }
    col[v] = 2;
}

// Driver Code

    g[0].push([1, 0]);
    g[0].push([2, 1]);
    g[1].push([2, 2]);
    g[1].push([3, 3]);
    g[2].push([3, 4]);
    g[3].push([4, 5]);
    g[4].push([2, 6]);

    // Loop to run DFS Traversal on
    // vertex which is not visited
    for (let i = 0; i < n; ++i) {
        if (col[i] == 0)
        {
            dfs(i);
        }
    }
    document.write((cyc ? 2 : 1) + "<br>");

    // Loop to print the
    // colors of the edges
    for (let i = 0; i < m; ++i) {
        document.write(res[i] + ' ');
    }

    // This code is contributed by _saurabh_jaiswal
</script>

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