Edge Coloring of a Graph - GeeksforGeeks

07 Dec, 2021
In graph theory, edge coloring of a graph is an assignment of “colors” to the edges of the graph so that no two adjacent edges have the same color with an optimal number of colors. Two edges are said to be adjacent if they are connected to the same vertex. There is no known polynomial time algorithm for edge-coloring every graph with an optimal number of colors. Nevertheless, a number of algorithms have been developed that relax one or more of these criteria, they only work on a subset of graphs, or they do not always use an optimal number of colors, or they do not always run in polynomial time.Examples:  
Input : u1 = 1, v1 = 4 
        u2 = 1, v2 = 2
        u3 = 2, v3 = 3
        u4 = 3, v4 = 4
Output : Edge 1 is of color 1
         Edge 2 is of color 2
         Edge 3 is of color 1
         Edge 4 is of color 2

The above input shows the pair of vertices(ui, vi)
who have an edge between them. The output shows the color 
assigned to the respective edges.
 
 
Edge colorings are one of several different types of graph coloring problems. The above figure of a Graph shows an edge coloring of a graph by the colors green and black, in which no adjacent edge have the same color.Below is an algorithm to solve the edge coloring problem which may not use an optimal number of colors: Algorithm:  
Use BFS traversal to start traversing the graph.Pick any vertex and give different colors to all of the edges connected to it, and mark those edges as colored.Traverse one of it’s edges.Repeat step to with a new vertexd until all edges are colored.
Use BFS traversal to start traversing the graph.
Pick any vertex and give different colors to all of the edges connected to it, and mark those edges as colored.
Traverse one of it’s edges.
Repeat step to with a new vertexd until all edges are colored.
Below is the implementation of above approach:  
C++
Python3
// C++ program to illustrate Edge Coloring#include <bits/stdc++.h>using namespace std; // function to determine the edge colorsvoid colorEdges(int ptr, vector<vector<pair<int, int> > >& gra,                vector<int>& edgeColors, bool isVisited[]){    queue<int> q;    int c = 0;     unordered_set<int> colored;     // return if isVisited[ptr] is true    if (isVisited[ptr])        return;     // Mark the current node visited    isVisited[ptr] = 1;     // Traverse all edges of current vertex    for (int i = 0; i < gra[ptr].size(); i++) {        // if already colored, insert it into the set        if (edgeColors[gra[ptr][i].second] != -1)            colored.insert(edgeColors[gra[ptr][i].second]);    }     for (int i = 0; i < gra[ptr].size(); i++) {        // if not visited, inset into the queue        if (!isVisited[gra[ptr][i].first])            q.push(gra[ptr][i].first);         if (edgeColors[gra[ptr][i].second] == -1) {            // if col vector -> negative            while (colored.find(c) != colored.end())                 // increment the color                c++;             // copy it in the vector            edgeColors[gra[ptr][i].second] = c;             // then add it to the set            colored.insert(c);            c++;        }    }     // while queue's not empty    while (!q.empty()) {        int temp = q.front();        q.pop();         colorEdges(temp, gra, edgeColors, isVisited);    }     return;} // Driver Functionint main(){    set<int> empty;     // declaring vector of vector of pairs, to define Graph    vector<vector<pair<int, int> > > gra;     vector<int> edgeColors;     bool isVisited[100000] = { 0 };     // Enter the Number of Vertices    // and the number of edges    int ver = 4;    int edge = 4;     gra.resize(ver);    edgeColors.resize(edge, -1);     // Enter edge & vertices of edge    // x--; y--;    // Since graph is undirected, push both pairs    // (x, y) and (y, x)    // graph[x].push_back(make_pair(y, i));    // graph[y].push_back(make_pair(x, i));    gra[0].push_back(make_pair(1, 0));    gra[1].push_back(make_pair(0, 0));     gra[1].push_back(make_pair(2, 1));    gra[2].push_back(make_pair(1, 1));     gra[2].push_back(make_pair(3, 2));    gra[3].push_back(make_pair(2, 2));     gra[0].push_back(make_pair(3, 3));    gra[3].push_back(make_pair(0, 3));     colorEdges(0, gra, edgeColors, isVisited);     // printing all the edge colors    for (int i = 0; i < edge; i++)        cout << "Edge " << i + 1 << " is of color "             << edgeColors[i] + 1 << "\n";     return 0;}
# Python3 program to illustrate Edge Coloring from queue import Queue# function to determine the edge colorsdef colorEdges(ptr, gra, edgeColors, isVisited):    q=Queue()    c = 0     colored=set()     # return if isVisited[ptr] is true    if (isVisited[ptr]):        return     # Mark the current node visited    isVisited[ptr] = True     # Traverse all edges of current vertex    for i in range(len(gra[ptr])) :        # if already colored, insert it into the set        if (edgeColors[gra[ptr][i][1]] != -1):            colored.add(edgeColors[gra[ptr][i][1]])          for i in range(len(gra[ptr])) :        # if not visited, inset into the queue        if not isVisited[gra[ptr][i][0]]:            q.put(gra[ptr][i][0])         if (edgeColors[gra[ptr][i][1]] == -1) :            # if col vector -> negative            while c in colored:                 # increment the color                c+=1             # copy it in the vector            edgeColors[gra[ptr][i][1]] = c             # then add it to the set            colored.add(c)            c+=1                   # while queue's not empty    while not q.empty() :        temp = q.get()         colorEdges(temp, gra, edgeColors, isVisited)          return  # Driver Functionif __name__=='__main__':    empty=set()     # declaring vector of vector of pairs, to define Graph    gra=[]     edgeColors=[]     isVisited=[False]*100000     # Enter the Number of Vertices    # and the number of edges    ver = 4    edge = 4     gra=[[] for _ in range(ver)]    edgeColors=[-1]*edge     # Enter edge & vertices of edge    # x-- y--    # Since graph is undirected, push both pairs    # (x, y) and (y, x)    # graph[x].append((y, i))    # graph[y].append((x, i))    gra[0].append((1, 0))    gra[1].append((0, 0))     gra[1].append((2, 1))    gra[2].append((1, 1))     gra[2].append((3, 2))    gra[3].append((2, 2))     gra[0].append((3, 3))    gra[3].append((0, 3))     colorEdges(0, gra, edgeColors, isVisited)     # printing all the edge colors    for i in range(edge):        print("Edge {} is of color {}".format(i + 1,edgeColors[i] + 1))
Edge 1 is of color 1
Edge 2 is of color 2
Edge 3 is of color 1
Edge 4 is of color 2
 
Time Complexity: O(N) Where N is the number of nodes in the graph.Auxiliary Space: O(N) Reference : https://en.wikipedia.org/wiki/Edge_coloring 
arorakashish0911
pankajsharmagfg
amartyaghoshgfg
Algorithms-Graph Traversals
BFS
Graph Coloring
Algorithms
Graph
Graph
BFS
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
DSA Sheet by Love Babbar
How to Start Learning DSA?
K means Clustering - Introduction
Types of Complexity Classes | P, NP, CoNP, NP hard and NP complete
Quadratic Probing in Hashing
Breadth First Search or BFS for a Graph
Depth First Search or DFS for a Graph
Dijkstra's shortest path algorithm | Greedy Algo-7
Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2
Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5