Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Welsh Powell Graph Colouring Algorithm
A key concern in information technology, graph colouring has numerous applications in fields including scheduling, register assignment, and map colouring. An effective method for colouring graphs that makes sure nearby vertices have various shades while using fewer colours is the Welsh Powell algorithm. In this post, we'll examine 2 ways to use C++ algorithms to create the Welsh Powell algorithm.
Methods Used
Sequential Vertex Ordering
Largest First Vertex Ordering
Sequential Vertex Ordering
In the first technique, colours are successively assigned to the vertices after they are arranged in decreasing order according to their degrees. This technique makes sure that greater−degree vertices, which often have more neighbours, are coloured first.
Algorithm
Determine the level of each graph vertex.
Determine the vertices' degrees and sort them in decreasing order.
Set the allotted colours for each vertex's location in an array.
Repeat step 2 over the vertices in the order determined there.
Give each vertex the smallest colour that isn't already being utilised by its neighbouring vertices.
Example
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// Graph structure
struct Graph {
int V; // Number of vertices
vector<vector<int>> adj; // Adjacency list
// Constructor
Graph(int v) : V(v), adj(v) {}
// Function to add an edge between two vertices
void addEdge(int u, int v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
};
// Function to compare vertices based on weight
bool compareWeights(pair<int, int> a, pair<int, int> b) {
return a.second > b.second;
}
// Function to perform graph coloring using Welsh-Powell algorithm
void graphColoring(Graph& graph) {
int V = graph.V;
vector<pair<int, int>> vertexWeights;
// Assign weights to each vertex based on their degree
for (int v = 0; v < V; v++) {
int weight = graph.adj[v].size();
vertexWeights.push_back(make_pair(v, weight));
}
// Sort vertices in descending order of weights
sort(vertexWeights.begin(), vertexWeights.end(), compareWeights);
// Array to store colors assigned to vertices
vector<int> color(V, -1);
// Assign colors to vertices in the sorted order
for (int i = 0; i < V; i++) {
int v = vertexWeights[i].first;
// Find the smallest unused color for the current vertex
vector<bool> usedColors(V, false);
for (int adjVertex : graph.adj[v]) {
if (color[adjVertex] != -1)
usedColors[color[adjVertex]] = true;
}
// Assign the smallest unused color to the current vertex
for (int c = 0; c < V; c++) {
if (!usedColors[c]) {
color[v] = c;
break;
}
}
}
// Print the coloring result
for (int v = 0; v < V; v++) {
cout << "Vertex " << v << " is assigned color " << color[v] << endl;
}
}
int main() {
// Create a sample graph
Graph graph(6);
graph.addEdge(0, 1);
graph.addEdge(0, 2);
graph.addEdge(1, 2);
graph.addEdge(1, 3);
graph.addEdge(2, 3);
graph.addEdge(3, 4);
graph.addEdge(4, 5);
// Perform graph coloring
graphColoring(graph);
return 0;
}
Output
Vertex 0 is assigned color 2 Vertex 1 is assigned color 0 Vertex 2 is assigned color 1 Vertex 3 is assigned color 2 Vertex 4 is assigned color 0 Vertex 5 is assigned color 1
Largest First Vertex Ordering
Similar to way 1, the second way includes arranging the vertices in decreasing order according to their degrees. This approach colours the highest degree vertex first and recursively colours its uncolored neighbours, as opposed to sequentially allocating colours.
Algorithm
Determine the degree of each graph vertex.
Determine the vertices' degrees and sort them in descending sequence.
Set the allotted colours for each vertex's location in an array.
Start colouring at the greatest degree vertex.
Choose the least colour that is available for each neighbour of the present vertex that is not coloured.
Example
#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_set>
using namespace std;
class Graph {
private:
int numVertices;
vector<unordered_set<int>> adjacencyList;
public:
Graph(int vertices) {
numVertices = vertices;
adjacencyList.resize(numVertices);
}
void addEdge(int src, int dest) {
adjacencyList[src].insert(dest);
adjacencyList[dest].insert(src);
}
int getNumVertices() {
return numVertices;
}
unordered_set<int>& getNeighbors(int vertex) {
return adjacencyList[vertex];
}
};
void welshPowellLargestFirst(Graph graph) {
int numVertices = graph.getNumVertices();
vector<int> colors(numVertices, -1);
vector<pair<int, int>> largestFirst;
for (int i = 0; i < numVertices; i++) {
largestFirst.push_back(make_pair(graph.getNeighbors(i).size(), i));
}
sort(largestFirst.rbegin(), largestFirst.rend());
int numColors = 0;
for (const auto& vertexPair : largestFirst) {
int vertex = vertexPair.second;
if (colors[vertex] != -1) {
continue; // Vertex already colored
}
colors[vertex] = numColors;
for (int neighbor : graph.getNeighbors(vertex)) {
if (colors[neighbor] == -1) {
colors[neighbor] = numColors;
}
}
numColors++;
}
// Print assigned colors
for (int i = 0; i < numVertices; i++) {
cout << "Vertex " << i << " - Color: " << colors[i] << endl;
}
}
int main() {
Graph graph(7);
graph.addEdge(0, 1);
graph.addEdge(0, 2);
graph.addEdge(0, 3);
graph.addEdge(1, 4);
graph.addEdge(1, 5);
graph.addEdge(2, 6);
graph.addEdge(3, 6);
welshPowellLargestFirst(graph);
return 0;
}
Output
Vertex 0 - Color: 0 Vertex 1 - Color: 0 Vertex 2 - Color: 1 Vertex 3 - Color: 1 Vertex 4 - Color: 0 Vertex 5 - Color: 0 Vertex 6 - Color: 1
Conclusion
This blog post analyzed two distinct ways to build the Welsh Powell graph colouring technique employing C++ algorithms. Each method took a different tack when it came to sorting vertices and allocating colours, producing methods for graph colouring that were effective and optimised. We may efficiently reduce the number of colours needed while guaranteeing that nearby vertex contain distinct colours by using these techniques. With its adaptability and simplicity, the Welsh Powell algorithm is still a useful tool in a variety of graph colouring applications.
732 Views
To Continue Learning Please Login