V0.1

Author: aniketshedge-packt

Lesson06/Activity01/bipartite_check.cpp

@@ -0,0 +1,193 @@
+#include <string>
+#include <vector>
+#include <iostream>
+#include <set>
+#include <map>
+#include <stack>
+
+template<typename T>
+struct Edge
+{
+size_t src;
+size_t dest;
+T weight;
+
+// To compare edges, only compare their weights,
+// and not the source/destination vertices
+inline bool operator< (const Edge<T>& e) const
+{
+return this->weight < e.weight;
+}
+
+inline bool operator> (const Edge<T>& e) const
+{
+return this->weight > e.weight;
+}
+};
+
+template<typename T>
+class Graph
+{
+public:
+// Initialize the graph with N vertices
+Graph(size_t N) : V(N)
+{}
+
+// Return number of vertices in the graph
+auto vertices() const
+{
+return V;
+}
+
+// Return all edges in the graph
+auto& edges() const
+{
+return edge_list;
+}
+
+void add_edge(Edge<T>& e)
+{
+// Check if the source and destination vertices are within range
+if (e.src >= 1 && e.src <= V &&
+e.dest >= 1 && e.dest <= V)
+edge_list.emplace_back(e);
+else
+std::cerr << "Vertex out of bounds" << std::endl;
+}
+
+// Returns all outgoing edges from vertex v
+auto outgoing_edges(size_t v) const
+{
+std::vector<Edge<T>> edges_from_v;
+for (auto& e : edge_list)
+{
+if (e.src == v)
+edges_from_v.emplace_back(e);
+}
+return edges_from_v;
+}
+
+// Overloads the << operator so a graph be written directly to a stream
+// Can be used as std::cout << obj << std::endl;
+template <typename T>
+friend std::ostream& operator<<(std::ostream& os, const Graph<T>& G);
+
+private:
+size_t V;// Stores number of vertices in graph
+std::vector<Edge<T>> edge_list;
+};
+
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const Graph<T>& G)
+{
+for (auto i = 1; i < G.vertices(); i++)
+{
+os << i << ":\t";
+
+auto edges = G.outgoing_edges(i);
+for (auto& e : edges)
+os << "{" << e.dest << ": " << e.weight << "}, ";
+
+os << std::endl;
+}
+
+return os;
+}
+
+template <typename T>
+auto create_bipartite_reference_graph()
+{
+Graph<T> G(10);
+
+std::map<unsigned, std::vector<std::pair<size_t, T>>> edges;
+edges[1] = { {2, 0} };
+edges[2] = { {1, 0}, {3, 0} , {8, 0} };
+edges[3] = { {2, 0}, {4, 0} };
+edges[4] = { {3, 0}, {6, 0} };
+edges[5] = { {7, 0}, {9, 0} };
+edges[6] = { {1, 0}, {4, 0} };
+edges[7] = { {5, 0} };
+edges[8] = { {2,0}, {9, 0} };
+edges[9] = { {5, 0} };
+
+
+for (auto& i : edges)
+for (auto& j : i.second)
+G.add_edge(Edge<T>{ i.first, j.first, j.second });
+
+return G;
+}
+
+template <typename T>
+auto bipartite_check(const Graph<T>& G)
+{
+std::stack<size_t> stack;
+std::set<size_t> visited;
+stack.push(1); // Assume that BFS always starts from vertex ID 1
+
+enum class colors {NONE, RED, BLUE};
+colors current_color{colors::BLUE}; // This variable tracks the color to be assigned to the
+// next vertex that is visited.
+std::vector<colors> vertex_colors(G.vertices(), colors::NONE);
+
+while (!stack.empty())
+{
+auto current_vertex = stack.top();
+stack.pop();
+
+// If the current vertex hasn't been visited in the past
+if (visited.find(current_vertex) == visited.end())
+{
+visited.insert(current_vertex);
+vertex_colors[current_vertex] = current_color;
+if (current_color == colors::RED)
+{
+std::cout << "Coloring vertex " << current_vertex << " RED" << std::endl;
+current_color = colors::BLUE;
+}
+else
+{
+std::cout << "Coloring vertex " << current_vertex << " BLUE" << std::endl;
+current_color = colors::RED;
+}
+
+// Add unvisited adjacent vertices to the stack.
+for (auto e : G.outgoing_edges(current_vertex))
+if (visited.find(e.dest) == visited.end())
+stack.push(e.dest);
+}
+// If the found vertex is already colored and 
+// has a color same as its parent's color, the graph is not bipartite
+else if (visited.find(current_vertex) != visited.end() && 
+((vertex_colors[current_vertex] == colors::BLUE && 
+current_color == colors::RED) ||
+(vertex_colors[current_vertex] == colors::RED && 
+current_color == colors::BLUE)))
+return false;
+}
+
+// If all vertices have been colored, the graph is bipartite
+return true;
+}
+
+template <typename T>
+void test_bipartite()
+{
+// Create an instance of and print the graph
+auto BG = create_bipartite_reference_graph<T>();
+std::cout << BG << std::endl;
+
+if (bipartite_check<T>(BG))
+std::cout << "The graph is bipartite" << std::endl;
+else
+std::cout << "The graph is not bipartite" << std::endl;
+}
+
+int main()
+{
+using T = unsigned;
+test_bipartite<T>();
+
+return 0;
+}
+